Ë
    z�hQ  ã                  óô   — d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlm	Z	 ddlm
Z
 ddlmZ dd	lmZ dd
lmZ ddlmZ er(ddlmZ ddlmZ ddlZddlZddlmZ ddlmZ eeef   ZneZdgZ G d„ de«      Zy)zxSchema.

Adapted from Polars implementation at:
https://github.com/pola-rs/polars/blob/main/py-polars/polars/schema.py.
é    )Úannotations)ÚOrderedDict)Úpartial)ÚTYPE_CHECKING)ÚIterable)ÚMapping)Úcast)ÚImplementation)ÚVersion)Úparse_version)ÚAny)ÚClassVarN)ÚDType)ÚDTypeBackendÚSchemac                  óŒ   ‡ — e Zd ZU dZej
                  Zded<   	 d	 	 	 dˆ fd„Zdd„Z	dd„Z
dd„Zdd„Z	 d	 	 	 dd	„Zdd
„Zˆ xZS )r   a‚  Ordered mapping of column names to their data type.

    Arguments:
        schema: Mapping[str, DType] | Iterable[tuple[str, DType]] | None
            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
    zClassVar[Version]Ú_versionc                ó0   •— |xs i }t         ‰| �  |«       y ©N)ÚsuperÚ__init__)ÚselfÚschemaÚ	__class__s     €úM/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/narwhals/schema.pyr   zSchema.__init__G   s   ø€ ð ’˜2ˆÜ‰Ñ˜Õ ó    c                ó4   — t        | j                  «       «      S )zXGet the column names of the schema.

        Returns:
            Column names.
        )ÚlistÚkeys©r   s    r   ÚnameszSchema.namesN   s   € ô �D—I‘I“KÓ Ð r   c                ó4   — t        | j                  «       «      S )z^Get the data types of the schema.

        Returns:
            Data types of schema.
        )r   Úvaluesr    s    r   ÚdtypeszSchema.dtypesV   s   € ô �D—K‘K“MÓ"Ð"r   c                ó   — t        | «      S )zbGet the number of columns in the schema.

        Returns:
            Number of columns.
        )Úlenr    s    r   r&   z
Schema.len^   s   € ô �4‹yÐr   c                ón   ‡ ‡— ddl }ddlmŠ  |j                  ˆˆ fd„‰ j	                  «       D «       «      S )a7  Convert Schema to a pyarrow Schema.

        Returns:
            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]
        r   N©Únarwhals_to_native_dtypec              3  óN   •K  — | ]  \  }}| ‰|‰j                   «      f–— Œ y ­wr   ©r   )Ú.0ÚnameÚdtyper)   r   s      €€r   ú	<genexpr>z"Schema.to_arrow.<locals>.<genexpr>w   s.   øè ø€ ò 
á��eð Ñ+¨E°4·=±=ÓAÔBñ
ùs   ƒ"%)ÚpyarrowÚnarwhals._arrow.utilsr)   r   Úitems)r   Úpar)   s   ` @r   Úto_arrowzSchema.to_arrowf   s1   ù€ ó 	åBàˆr�y‰yô 
à#Ÿz™z›|ô
ó 
ð 	
r   c                óÌ  — ddl }ddlm} t        |t        j
                  t        |«      | j                  ¬«      }|�t        |t        «      r,| j                  «       D ��ci c]  \  }}| |||¬«      “Œ c}}S t        |«      }t        |«      t        | «      k7  rvddlm} ddlm}	 ddlm}
 t        |«      t        | «      }}t         |	|j#                   |	 |
|«      |«      «      |«      «      }d	|›d
|›d|› d|d   › d|› d�}t%        |«      ‚t'        | j)                  «       | j+                  «       |«      D ���ci c]  \  }}}| |||¬«      “Œ c}}}S c c}}w c c}}}w )aÉ  Convert 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.

        Returns:
            An ordered mapping of column names to their pandas data type.

        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]'}
        r   Nr(   )ÚimplementationÚbackend_versionÚversion)r.   Údtype_backend)Úchain)Úislice)Úrepeatz	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(ú))ÚpandasÚnarwhals._pandas_like.utilsr)   r   r
   ÚPANDASr   r   Ú
isinstanceÚstrr2   Útupler&   Ú	itertoolsr:   r;   r<   Úfrom_iterableÚ
ValueErrorÚzipr   r#   )r   r9   Úpdr)   Úto_native_dtyper-   r.   Úbackendsr:   r;   r<   Ún_userÚn_actualÚ
suggestionÚmsgÚbackends                   r   Ú	to_pandaszSchema.to_pandas|   sx  € ó* 	åHä!Ø$Ü)×0Ñ0Ü)¨"Ó-Ø—M‘Mô	
ˆð Ð ¤J¨}¼cÔ$Bð $(§:¡:£<÷á�D˜%ð ‘o¨EÀÔOÑOóð ô
 ˜]Ó+ˆHÜ�8‹}¤ D£	Ò)Ý+Ý,Ý,ä#& x£=´#°d³)˜�Ü"ÙØ×+Ñ+©F±6¸(Ó3CÀXÓ,NÓOÐQYóó�
ð   ˜zÐ)RÐS[ÐR^ð _,à,4¨:ð 6,à,4°Q©K¨=ð 9,à,6¨<°qð:ð ô ! “oÐ%ô -0°·	±	³¸T¿[¹[»]ÈHÓ,U÷ð á(�D˜% ð ‘o¨EÀÔIÑIôð ùó7ùô6s   Á EÄ>Ec                óÀ   ‡ ‡‡— ddl }ddlmŠ t        |«      Šˆˆˆ fd„‰ j	                  «       D «       }‰dk\  r |j
                  |«      S t        dt        |«      «      S )ax  Convert Schema to a polars Schema.

        Returns:
            A polars Schema or plain dict (prior to polars 1.0).

        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)})
        r   Nr(   c              3  óR   •K  — | ]  \  }}| ‰|‰j                   ‰¬ «      f–— Œ  y­w))r7   Nr+   )r,   r-   r.   r)   Ú
pl_versionr   s      €€€r   r/   z#Schema.to_polars.<locals>.<genexpr>Í   s7   øè ø€ ò 
ñ ��eð Ù(Ø˜4Ÿ=™=¸*ôôñ
ùs   ƒ$')é   r   r   ú	pl.Schema)ÚpolarsÚnarwhals._polars.utilsr)   r   r2   r   r	   Údict)r   Úplr   r)   rS   s   `  @@r   Ú	to_polarszSchema.to_polars¼   s`   ú€ ó 	åCä" 2Ó&ˆ
õ
ð  $Ÿz™z›|ô
ˆð ˜YÒ&ð ˆB�I‰I�fÓð	
ô �k¤4¨£<Ó0ð	
r   r   )r   z8Mapping[str, DType] | Iterable[tuple[str, DType]] | NoneÚreturnÚNone)r[   z	list[str])r[   zlist[DType])r[   Úint)r[   z	pa.Schema)r9   z%DTypeBackend | Iterable[DTypeBackend]r[   zdict[str, Any])r[   rU   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   ÚMAINr   Ú__annotations__r   r!   r$   r&   r4   rP   rZ   Ú__classcell__)r   s   @r   r   r   &   sm   ø… ñð< #*§,¡,€HÐÓ.ð LPð!àHð!ð 
õ!ó!ó#óó
ð. FJð>ØBð>à	ó>÷@
r   )ra   Ú
__future__r   Úcollectionsr   Ú	functoolsr   Útypingr   r   r   r	   Únarwhals.utilsr
   r   r   r   r   rV   rY   r0   r3   Únarwhals.dtypesr   Únarwhals.typingr   rB   Ú
BaseSchemaÚ__all__r   © r   r   ú<module>ro      si   ðñõ #å #Ý Ý  Ý Ý Ý å )Ý "Ý (áÝÝãÛå%Ý,à˜S %˜ZÑ(�Jð €Jàˆ*€ôt
ˆZõ t
r   