hhQ0dZddlmZddlmZddlmZddlmZddl m Z m Z ddl m Z mZmZmZddlmZmZmZmZmZmZmZe r.dd lmZdd l mZmZdd lZdd lZdd l m!Z!dd l"m#Z#ddl$m%Z%m&Z&m'Z'm(Z(dgZ)Gddee*dfZ+d S)zxSchema. Adapted from Polars implementation at: https://github.com/pola-rs/polars/blob/main/py-polars/polars/schema.py. ) annotations) OrderedDict)Mapping)partial) TYPE_CHECKINGcast)ImplementationVersionqualified_type_name zip_strict)get_cudf is_cudf_dtypeis_pandas_like_dtypeis_polars_data_typeis_polars_schemais_pyarrow_data_typeis_pyarrow_schema)Iterable)AnyClassVarN)Self)DType) DTypeBackendIntoArrowSchemaIntoPandasSchemaIntoPolarsSchemaSchemaceZdZUdZejZded< d'd(fd Zd)d Z d*d Z d+dZ e d,dZ e d-dZe d.dZe d/dZd0dZ d'd1dZd2d Ze d3d#Ze d4d&ZxZS)5ra<Ordered mapping of column names to their data type. Arguments: schema: The schema definition given by column names and their associated *instantiated* Narwhals data type. Accepts a mapping or an iterable of tuples. Examples: Define a schema by passing *instantiated* data types. >>> 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]_versionNschema8Mapping[str, DType] | Iterable[tuple[str, DType]] | NonereturnNonecR|pi}t|dSN)super__init__)selfr __class__s F/var/www/histauto/venv/lib/python3.11/site-packages/narwhals/schema.pyr'zSchema.__init__Ms,2      list[str]cDt|S)z#Get the column names of the schema.)listkeysr(s r*namesz Schema.namesSsDIIKK   r+ list[DType]cDt|S)z!Get the data types of the schema.)r.valuesr0s r*dtypesz Schema.dtypesWsDKKMM"""r+intc t|S)z(Get the number of columns in the schema.)lenr0s r*r8z Schema.len[s4yyr+rrct|tr |s Sddl}|j|}ddlmfd|DS)aConstruct 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_dtypec3RK|]!}|j|jjfV"dSr%)nametyper).0fieldclsr;s r* z$Schema.from_arrow..sP  Z11%*clKK L      r+) isinstancerpyarrowr narwhals._arrow.utilsr;)rAr par;s` @r* from_arrowzSchema.from_arrow_s2 fg & & ' suu RYv&&FBBBBBBs           r+rc|s |Str7td|Dr tjn tj}|||S)a3Construct 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}) c34K|]}t|VdSr%)r)r?dtypes r*rBz*Schema.from_pandas_like..s*!T!T5-"6"6!T!T!T!T!T!Tr+)r anyr4r CUDFPANDAS_from_pandas_like)rAr impls r*from_pandas_likezSchema.from_pandas_likesw: 355Lzz '!!T!TFMMOO!T!T!TTT 'N  & $$VT222r+5IntoArrowSchema | IntoPolarsSchema | IntoPandasSchemacFt|r||St|r||St |t r!|r||n |Sdt|d|}t|)aoConstruct 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 ) rrGr from_polarsrCr_from_native_mappingr TypeError)rAr msgs r* from_nativezSchema.from_natives* V $ $ *>>&)) ) F # # +??6** * fg & & I7=H3++F3333355 H ="6** = =28 = = nnr+rc~|s Sddlmfd|DS)a/Construct 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 rr:c3DK|]\}}||jfVdSr%r)r?r=rJrAr;s r*rBz%Schema.from_polars..sP  e++E3<@@ A      r+)narwhals._polars.utilsr;items)rAr r;s` @r*rSzSchema.from_polarssr4 355LCCCCCCs     %||~~      r+ pa.Schemacxddl}ddlm|jfdDS)aConvert 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_dtypec3DK|]\}}||jfVdSr%rZr?r=rJr`r(s r*rBz"Schema.to_arrow..sP  e++E4=AA B      r+)rDrEr`r r\)r(rFr`s` @r*to_arrowzSchema.to_arrowsm BBBBBBry     #zz||      r+ dtype_backend%DTypeBackend | Iterable[DTypeBackend]dict[str, Any]c  ddlm}t|tj|j t tr! fd|DSt}t|t|krddl m }m }m}t|t|}}t|||||||} d|d|d |d |dd | d } t!|  fd t#|||DS)amConvert 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]'} rr_)implementationversionNc2i|]\}}||S)rJrd)r?r=rJrdto_native_dtypes r* z$Schema.to_pandas..s>D%ooEOOOr+)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()c4i|]\}}}|||Srkrl)r?r=rJbackendrms r*rnz$Schema.to_pandas..2s@   $eW //WEEE   r+)narwhals._pandas_like.utilsr`rr rMrrCstrr\tupler8 itertoolsrorprq from_iterable ValueErrorr r/r4) r(rdr`backendsrorprqn_usern_actual suggestionrVrms ` @r* to_pandaszSchema.to_pandass$ IHHHHH! $)0M     J}c$B$B #'::<< '' x==CII % % 7 7 7 7 7 7 7 7 7 7"8}}c$iiHFu**66&&2B2BH+M+MNNPXYYJ6F66x66(066)1 66 )3 666 S// !    (2499;; x(X(X    r+ pl.Schemacddl}ddlmtj}fdD}|dkr|j|ntdt|S)a%Convert 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)}) rNr_c3DK|]\}}||jfVdSr%rZrbs r*rBz#Schema.to_polars..EsP  e++E4=AA B      r+)rrr) polarsr[r`r POLARS_backend_versionr\rrdict)r(pl pl_versionr r`s` @r* to_polarszSchema.to_polars7s CCCCCC#*;;==      #zz||    Y&& BIf   k4<<00 r+nativeHMapping[str, pa.DataType] | Mapping[str, pl.DataType] | IntoPandasSchemactt|}|\}}t|r#|t d|St |r#|t d|St|r#| t d|Sd|dt|d|}t|)Nrrrz7Expected an arrow, polars, or pandas dtype, but found `z: z` ) nextiterr\rrSrrrPrrGr rU)rAr first_item first_key first_dtyperVs r*rTzSchema._from_native_mappingOs $v||~~..// !+ ; { + + E??4(:F#C#CDD D  , , J''-?(H(HII I  , , C>>$'8&"A"ABB B O O O0== O ODJ O O nnr+rhr cnddlm|fd|DS)Nrr:c3JK|]\}}||jdfVdS)T) allow_objectNrZ)r?r=rJrArOr;s r*rBz+Schema._from_pandas_like..jsX  e++E3<TXYYY Z      r+)rur;r\)rAr rhrOr;s` @@r*rNzSchema._from_pandas_likecsk IHHHHHs      %||~~      r+r%)r r!r"r#)r"r,)r"r2)r"r6)r rr"r)r rr"r)r rQr"r)r rr"r)r"r])rdrer"rf)r"r)rrr"r)r rrhr r"r)__name__ __module__ __qualname____doc__r MAINr__annotations__r'r1r5r8 classmethodrGrPrWrSrcrrrTrN __classcell__)r)s@r*rr-s:#*,H....RV!!!!!!! !!!!##### # # [# J#3#3#3[#3J[@    [  D    (FJ3 3 3 3 3 j    0[&    [      r+r),r __future__r collectionsrcollections.abcr functoolsrtypingrrnarwhals._utilsr r r r narwhals.dependenciesr rrrrrrrrrrrrDrFtyping_extensionsrnarwhals.dtypesrnarwhals.typingrrrr__all__rvrrlr+r*rs #"""""############&&&&&&&&TTTTTTTTTTTT(((((($$$$$$$$&&&&&&%%%%%% *@ @ @ @ @ [g &@ @ @ @ @ r+