ctj64dZddlmZddlmZddlmZddlmZddl m Z m Z m Z ddl mZmZmZddlmZmZmZmZmZmZmZdd lmZe r2dd lmZdd l mZmZdd lZdd l Z!dd l"m#Z#ddl$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,dgZ-ddZ.Gddee/dfZ0d 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_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 IntoDTypeIntoPandasSchemaIntoPolarsSchemaSchemaobjrreturn%TypeIs[SupportsItems[str, IntoDType]]c:t|ttfSN) isinstancedictr)r!s M/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/narwhals/schema.py_supports_itemsr)/s cD'? + ++c8eZdZUdZejZded<ed+d,d Z ed-d Z d+d.fd Z d/dZ d0dZ d1dZ e d2dZe d3dZe d4dZe d5dZd6dZ d+d7d"Zd8d$Ze d9d'Ze d:d*ZxZS);r aOrdered 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]_versionNschemaMapping[str, IntoDType] | Noner"NonecdSr%selfr-s r(__init__zSchema.__init__^sORsr*Iterable[tuple[str, IntoDType]]cdSr%r1r2s r(r4zSchema.__init__`sILr*@Mapping[str, IntoDType] | Iterable[tuple[str, IntoDType]] | Nonec|"tdStdt|r|n|DdS)Nc3bK|]*\}}|t|tr|n |fV+dSr%)r&r).0namedtypes r( z"Schema.__init__..isXD% 5% 8 8EuueeggFr*)superr4r)items)r3r- __class__s r(r4zSchema.__init__bs > GG        GG  6Ef6M6M$YFLLNNNSY     r* 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. )listkeysr3s r(namesz Schema.namesnsDIIKK   r* list[DType]cDt|S)z!Get the data types of the schema.)rCvaluesrEs r(dtypesz Schema.dtypeszsDKKMM"""r*intc t|S)z(Get the number of columns in the schema.)lenrEs r(rMz 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%)r;typer,)r:fieldclsrPs r(r=z$Schema.from_arrow..sP  Z11%*clKK L      r*)r&rpyarrowr-narwhals._arrow.utilsrP)rTr-parPs` @r( from_arrowzSchema.from_arrows2 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:r<s r(r=z*Schema.from_pandas_like..s*!T!T5-"6"6!T!T!T!T!T!Tr*)r anyrIr CUDFPANDAS_from_pandas_like)rTr-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 ) rrXr from_polarsr&r_from_native_mappingr TypeError)rTr-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 rrOc3DK|]\}}||jfVdSr%r,)r:r;r<rTrPs r(r=z%Schema.from_polars.. sP  e++E3<@@ A      r*)narwhals._polars.utilsrPr?)rTr-rPs` @r(rczSchema.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%rjr:r;r<ror3s r(r=z"Schema.to_arrow.. sP  e++E4=AA B      r*)rUrVror-r?)r3rWros` @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]'} rrn)implementationversionNc2i|]\}}||S)r<rsr1)r:r;r<rsto_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|]\}}}|||Srzr1)r:r;r<backendr{s r(r|z$Schema.to_pandas..Us@   $eW //WEEE   r*T)strict)narwhals._pandas_like.utilsrorr r]r,r&strr?tuplerM itertoolsr}r~r from_iterable ValueErrorziprDrI) r3rsrobackendsr}r~rn_usern_actual suggestionrfr{s ` @r( to_pandaszSchema.to_pandas%s$ 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)}) rNrnc3DK|]\}}||jfVdSr%rjrqs r(r=z#Schema.to_polars..jsP  e++E4=AA B      r*)rrr) polarsrkror POLARS_backend_versionr?r rr')r3pl pl_versionr-ros` @r( to_polarszSchema.to_polars\s 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?rrcrrr`rrXr re)rTr first_item first_key first_dtyperfs r(rdzSchema._from_native_mappingts $v||~~..// !+ ; { + + E??4(:F#C#CDD D  , , J''-?(H(HII I  , , C>>$'8&"A"ABB B O O O0== O ODJ O O nnr*rwr cnddlm|fd|DS)NrrOc3JK|]\}}||jdfVdS)T) allow_objectNrj)r:r;r<rTr_rPs r(r=z+Schema._from_pandas_like..sX  e++E3<TXYYY Z      r*)rrPr?)rTr-rwr_rPs` @@r(r^zSchema._from_pandas_likesk IHHHHHs      %||~~      r*r%)r-r.r"r/)r-r5r"r/)r-r7r"r/)r"rA)r"rG)r"rK)r-rr"r)r-rr"r)r-rar"r)r-rr"r)r"rl)rsrtr"ru)r"r)rrr"r)r-rrwr r"r)__name__ __module__ __qualname____doc__r MAINr,__annotations__r r4rFrJrM classmethodrXr`rgrcrrrrrdr^ __classcell__)r@s@r(r r 6s##J#*,H.... RRRRXR LLLXLTX        ! ! ! !##### # # [# J#3#3#3[#3J[@    [  D    (FJ5 5 5 5 5 n    0[&    [      r*r)r!rr"r#)1r __future__r collectionsrcollections.abcr functoolsrtypingrrr narwhals._utilsr r r narwhals.dependenciesr rrrrrrnarwhals.dtypesrrrrrrrUrW _typeshedrtyping_extensionsrrnarwhals.typingrrrrr__all__r)rr r1r*r(rs! #"""""############0000000000HHHHHHHHHH"!!!!!(((((($$$$$$$$''''''........ *,,,,\ \ \ \ \ [g &\ \ \ \ \ r*