IZj2dZddlmZddlmZddlmZddlmZddl m Z m Z ddl m Z mZmZddlmZmZmZmZmZmZmZe r.dd lmZdd l mZmZdd lZdd lZdd lm 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)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)5ranOrdered 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 *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 [/Users/jameslopez/projects/MentorCore/.venv/lib/python3.11/site-packages/narwhals/schema.pyr&zSchema.__init__Ts,2      list[str]cDt|S)aoGet 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)namesz Schema.namesZsDIIKK   r* list[DType]cDt|S)z!Get the data types of the schema.)r-valuesr/s r)dtypesz Schema.dtypesfsDKKMM"""r*intc t|S)z(Get the number of columns in the schema.)lenr/s r)r7z Schema.lenjs4yyr*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*) isinstancerpyarrowrnarwhals._arrow.utilsr:)r@rpar:s` @r) from_arrowzSchema.from_arrowns2 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)rAz*Schema.from_pandas_like..s*!T!T5-"6"6!T!T!T!T!T!Tr*)r anyr3r CUDFPANDAS_from_pandas_like)r@rimpls 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 ) rrFr from_polarsrBr_from_native_mappingr TypeError)r@rmsgs 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 rr9c3DK|]\}}||jfVdSr$r)r>r<rIr@r:s r)rAz%Schema.from_polars..sP  e++E3<@@ A      r*)narwhals._polars.utilsr:items)r@rr:s` @r)rRzSchema.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$rYr>r<rIr_r's r)rAz"Schema.to_arrow.. sP  e++E4=AA B      r*)rCrDr_rr[)r'rEr_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#|||dDS)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)rIrc)r>r<rIrcto_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|]\}}}|||Srjrk)r>r<rIbackendrls r)rmz$Schema.to_pandas..As@   $eW //WEEE   r*T)strict)narwhals._pandas_like.utilsr_rr rLrrBstrr[tupler7 itertoolsrnrorp from_iterable ValueErrorzipr.r3) r'rcr_backendsrnrorpn_usern_actual suggestionrUrls ` @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// !    (+ T[[]]HT)))    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$rYras r)rAz#Schema.to_polars..VsP  e++E4=AA B      r*)rrr) polarsrZr_r POLARS_backend_versionr[rrdict)r'pl pl_versionrr_s` @r) to_polarszSchema.to_polarsHs 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[rrRrrrOrrFr rT)r@r first_item first_key first_dtyperUs r)rSzSchema._from_native_mapping`s $v||~~..// !+ ; { + + E??4(:F#C#CDD D  , , J''-?(H(HII I  , , C>>$'8&"A"ABB B O O O0== O ODJ O O nnr*rgr cnddlm|fd|DS)Nrr9c3JK|]\}}||jdfVdS)T) allow_objectNrY)r>r<rIr@rNr:s r)rAz+Schema._from_pandas_like..{sX  e++E3<TXYYY Z      r*)rur:r[)r@rrgrNr:s` @@r)rMzSchema._from_pandas_liketsk IHHHHHs      %||~~      r*r$)rr r!r")r!r+)r!r1)r!r5)rrr!r)rrr!r)rrPr!r)rrr!r)r!r\)rcrdr!re)r!r)rrr!r)rrrgr r!r)__name__ __module__ __qualname____doc__r MAINr__annotations__r&r0r4r7 classmethodrFrOrVrRrbrrrSrM __classcell__)r(s@r)rr-s""H#*,H....RV!!!!!!! ! ! ! !##### # # [# J#3#3#3[#3J[@    [  D    (FJ5 5 5 5 5 n    0[&    [      r*r)+r __future__r collectionsrcollections.abcr functoolsrtypingrrnarwhals._utilsr r r narwhals.dependenciesr r rrrrrrrrrrrCrEtyping_extensionsrnarwhals.dtypesrnarwhals.typingrrrr__all__rvrrkr*r)rs #"""""############&&&&&&&&HHHHHHHHHH(((((($$$$$$$$&&&&&&%%%%%% *Q Q Q Q Q [g &Q Q Q Q Q r*