7^j6&dZddlmZddlmZddlmZddlmZddl 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/dfZ0y )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.t|ttfSN) isinstancedictr)objs Z/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/narwhals/schema.py_supports_itemsr'/s cD'? ++c:eZdZUdZej Zded<edddZ eddZ d dfd Z ddZ ddZ dd Z e dd Ze dd Ze dd Ze dd ZddZ d ddZd dZe d!dZe d"dZxZS)#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]_versioncyr"selfschemas r&__init__zSchema.__init__^sORr(cyr"r,r-s r&r0zSchema.__init__`sILr(c|t|yt|dt|r|jn|Dy)Nc3XK|]"\}}|t|tr|n|f$ywr")r#r).0namedtypes r& z"Schema.__init__..is.D% 5% 8uegFs(*)superr0r'items)r.r/ __class__s r&r0zSchema.__init__bs? > G   G 6Ef6MFLLNSY r(c4t|jS)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.namesnsDIIK  r(c4t|jS)z!Get the data types of the schema.)r<valuesr>s r&dtypesz Schema.dtypeszsDKKM""r(ct|S)z(Get the number of columns in the schema.)lenr>s r&rDz Schema.len~s 4yr(ct|tr|sSddl}|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_dtypec3pK|]-}|j|jjf/ywr")r5typer*)r4fieldclsrGs r&r7z$Schema.from_arrow..s2 ZZ1%**cllK L s36)r#rpyarrowr/narwhals._arrow.utilsrG)rKr/parGs` @r& from_arrowzSchema.from_arrowsI2 fg &u RYYv&FB    r(c|s|Str0td|jDrtjntj }|j ||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}) c32K|]}t|ywr")r)r4r6s r&r7z*Schema.from_pandas_like..s!T5-"6!Ts)r anyrAr CUDFPANDAS_from_pandas_like)rKr/impls r&from_pandas_likezSchema.from_pandas_likesV:5Lzc!TFMMO!TT   && $$VT22r(ct|r|j|St|r|j|St |t r|r|j |S|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 ) rrOr from_polarsr#r_from_native_mappingr TypeError)rKr/msgs r& from_nativezSchema.from_natives* V $>>&) ) F #??6* * fg &7=3++F3 H35 HC"6*-T& = nr(cd|sSddlmfd|jDS)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 rrFc3NK|]\}}||jfywr"r*)r4r5r6rKrGs r&r7z%Schema.from_polars.. s. e+E3<<@ A "%)narwhals._polars.utilsrGr9)rKr/rGs` @r&rYzSchema.from_polarss245LC %||~   r(cnddl}ddlm|jfdj DS)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_dtypec3NK|]\}}||jfywr"r`r4r5r6rer.s r&r7z"Schema.to_arrow.. s. e+E4==A B ra)rLrMrer/r9)r.rNres` @r&to_arrowzSchema.to_arrows1 Bryy #zz|   r(c ddlm}t|tj|j }|t |tr,|jDcic]\}}||||c}}St|}t|t|k7rnddl m }m }m} t|t|} } t||j|| || | } d| d| d|d |dd | d } t!| t#|j%|j'|d Dcic]\}}}||||c}}}Scc}}wcc}}}w)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]'} rrd)implementationversion)r6 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.utilsrerr rTr*r#strr9tuplerD itertoolsrmrnro from_iterable ValueErrorzipr=rA)r.rlreto_native_dtyper5r6backendsrmrnron_usern_actual suggestionr\backends r& to_pandaszSchema.to_pandas%sk$ I! $)00MM   J}c$B$(::<D%oEOO ' x=CI % 7 7"8}c$iHFu**6&2BH+MNPXYJF:%Nxl[((0z2((0 }5((2|1 6 S/ !), T[[]HT)  $eW /WE E  -, s E*E cddl}ddlmtjj }fdj D}|dk\r|j|Stdt|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)}) rNrdc3NK|]\}}||jfywr"r`rgs r&r7z#Schema.to_polars..js. e+E4==A B ra)rr pl.Schema) polarsrbrer POLARS_backend_versionr9r rr$)r.pl pl_versionr/res` @r& to_polarszSchema.to_polars\sh C#**;;=  #zz|  Y& BIIf  k4<0 r(crtt|j}|\}}t|r|j t d|St |r|jt d|St|r|jt d|Sd|dt|d|}t|)Nrrrz7Expected an arrow, polars, or pandas dtype, but found `z: z` ) nextiterr9rrYrrrWrrOr r[)rKnative first_item first_key first_dtyper\s r&rZzSchema._from_native_mappingts $v||~./ !+ ; { +??4(:F#CD D  ,''-?(HI I  ,>>$'8&"AB B{"0=>eF: O nr(cZddlm|fd|jDS)NrrFc3TK|]\}}||jdf!yw)T) allow_objectNr`)r4r5r6rKrVrGs r&r7z+Schema._from_pandas_like..s3 e+E3<<TXY Z s%()rrrGr9)rKr/rjrVrGs` @@r&rUzSchema._from_pandas_likes. I %||~   r(r")r/zMapping[str, IntoDType] | NonereturnNone)r/zIterable[tuple[str, IntoDType]]rr)r/z@Mapping[str, IntoDType] | Iterable[tuple[str, IntoDType]] | Nonerr)rz list[str])rz list[DType])rint)r/rrr)r/rrr)r/z5IntoArrowSchema | IntoPolarsSchema | IntoPandasSchemarr)r/rrr)rz pa.Schema)rlz%DTypeBackend | Iterable[DTypeBackend]rzdict[str, Any])rr)rzHMapping[str, pa.DataType] | Mapping[str, pl.DataType] | IntoPandasSchemarr)r/rrjr rr)__name__ __module__ __qualname____doc__r MAINr*__annotations__r r0r?rBrD classmethodrOrWr]rYrhrrrZrU __classcell__)r:s@r&r r 6s@#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.dtypesrrrrrrrLrN _typeshedrtyping_extensionsrrnarwhals.typingrrrrr__all__r'rsr r,r(r&rs| ###00HH"($'. *,\ [g &\ r(