
    Whfg                       U d dl mZ d dlZd dlZd dlZd dlmZmZmZm	Z	m
Z
mZ d dlZd dlmZ d dlmZmZmZmZmZmZ d dlmZ d dlmZmZmZmZmZmZ d dl m!Z! erd d	l"m#Z#m$Z$m%Z% d d
l&m'Z' d dl(m)Z* d dl+m,Z, d dl-m.Z.m/Z/ d dl0m1Z1 d dl2m3Z3 d dl4m5Z5 d dl6m7Z7m8Z8m9Z9 d dl:m;Z; d dl<m=Z=m>Z>m?Z?m@Z@  e
de3      ZAe?ZBdeCd<   e?ZDdeCd<   eeeEgef   ZFdeCd<   eEZGdeCd<   ej                  ej                  ej                  hZKdZL ej                  eLej                        ZOdZP ej                  ePej                        ZQdZR ej                  eRej                        ZSdZT ej                  eTej                        ZUe	d   ZVdeCd <   d!d"d#ZWd$d%d&d'd(d)d*d+d,d-d.
ZXd/eCd0<   ej                  j                         ZZ	 dd2Z[	 	 	 	 	 	 dd4Z\	 	 	 	 	 	 	 	 dd5Z]	 	 	 	 	 	 	 	 	 	 dd6Z^ ej                  d78      dd9       Z`	 	 	 	 	 	 	 	 dd:Za	 d	 	 	 	 	 	 	 dd;Zb	 	 	 	 dd<Zcd=d>	 	 	 	 	 	 	 	 	 dd?Zdej                  j                         d@k\  rddAZenddBZeddCZf	 	 	 	 	 	 ddDZg ej                  d78      ddE       Zhej                  j                  Zjejj                  dFejj                  dGiZmdHeCdI<   ejj                  dJdKdLdMejj                  dNdOdPdMejj                  dQdRdSdMejj                  dTdUdVdMejj                  dWdXdYdMejj                  dZd[d\dMejj                  d]d^d_dMejj                  d`dadbdMejj                  dcdddedMejj                  dfdgdhdMejj                  didjeydMejj                  dkdld1dMiZ{dmeCdn<   ejj                  fZ}	 	 	 	 	 	 	 	 	 	 ddoZ~	 	 	 	 	 	 	 	 ddpZddqZej                  drfej                  dsfej                  efej                  drfej                  efej                  drfej                  efej                  efej                  efdt	ZdueCdv<   	 	 	 	 	 	 	 	 ddwZeeedxdyZdzeCd{<   dd|Z	 	 	 	 	 	 	 	 dd}Zdd~ZddZ G d ded3ef         Zy)    )annotationsN)TYPE_CHECKINGAnyCallableLiteralTypeVarcast)EagerSeriesNamespace)MS_PER_SECONDNS_PER_MICROSECONDNS_PER_MILLISECONDNS_PER_SECONDSECONDS_PER_DAYUS_PER_SECOND)issue_warning)ImplementationVersion_DeferredIterablecheck_columns_existisinstance_or_issubclassrequires)
ShapeError)IterableIteratorMapping)
ModuleType)DtypeBaseMaskedDtype)	TypeAliasTypeIs)IntervalUnit)PandasLikeExprPandasLikeSeries)NativeDataFrameTNativeNDFrameTNativeSeriesT)DType)DTypeBackend	IntoDTypeTimeUnit_1DArrayExprT)boundr    UnitCurrent
UnitTargetBinOpBroadcastIntoRhsa  ^
    datetime64\[
        (?P<time_unit>s|ms|us|ns)                 # Match time unit: s, ms, us, or ns
        (?:,                                      # Begin non-capturing group for optional timezone
            \s*                                   # Optional whitespace after comma
            (?P<time_zone>                        # Start named group for timezone
                [a-zA-Z\/]+                       # Match timezone name, e.g., UTC, America/New_York
                (?:[+-]\d{2}:\d{2})?              # Optional offset in format +HH:MM or -HH:MM
                |                                 # OR
                pytz\.FixedOffset\(\d+\)          # Match pytz.FixedOffset with integer offset in parentheses
            )                                     # End time_zone group
        )?                                        # End optional timezone group
    \]                                            # Closing bracket for datetime64
$a  ^
    timestamp\[
        (?P<time_unit>s|ms|us|ns)                 # Match time unit: s, ms, us, or ns
        (?:,                                      # Begin non-capturing group for optional timezone
            \s?tz=                                # Match "tz=" prefix
            (?P<time_zone>                        # Start named group for timezone
                [a-zA-Z\/]*                       # Match timezone name (e.g., UTC, America/New_York)
                (?:                               # Begin optional non-capturing group for offset
                    [+-]\d{2}:\d{2}               # Match offset in format +HH:MM or -HH:MM
                )?                                # End optional offset group
            )                                     # End time_zone group
        )?                                        # End optional timezone group
    \]                                            # Closing bracket for timestamp
    \[pyarrow\]                                   # Literal string "[pyarrow]"
$z^
    timedelta64\[
        (?P<time_unit>s|ms|us|ns)                 # Match time unit: s, ms, us, or ns
    \]                                            # Closing bracket for timedelta64
$a  ^
    duration\[
        (?P<time_unit>s|ms|us|ns)                 # Match time unit: s, ms, us, or ns
    \]                                            # Closing bracket for duration
    \[pyarrow\]                                   # Literal string "[pyarrow]"
$)yearquartermonthweekdayhourminutesecondmillisecondmicrosecond
nanosecondNativeIntervalUnitDmin)dmr4   r5   r6   r8   r9   r:   r;   r<   r=   r>   )
yqmorB   hrC   smsusnsz)Mapping[IntervalUnit, NativeIntervalUnit]
UNITS_DICTboolc                F    | t         j                  t         j                  hv S N)r   PANDASMODINimplementations    U/var/www/html/jupyter_env/lib/python3.12/site-packages/narwhals/_pandas_like/utils.pyis_pandas_or_modinrU      s    n33^5I5IJJJ    r%   c                X   ddl m} | j                  j                  }| j                  r=t        ||      r1|j                  s%| j                  j                  d   |j                  fS t        ||      r|j                  r%| j                  |j                  j                  d   fS |j                  j                  |ur.| j                  t        |j                  ||j                        fS | j                  |j                  fS t        |t              rd}t        |      | j                  |fS )zValidate RHS of binary operation.

    If the comparison isn't supported, return `NotImplemented` so that the
    "right-hand-side" operation (e.g. `__radd__`) can be tried.
    r   r$   rR   z$Expected Series or scalar, got list.)narwhals._pandas_like.seriesr%   nativeindex
_broadcast
isinstanceiloc	set_index_implementationlist	TypeError)lhsrhsr%   	lhs_indexmsgs        rT   align_and_extract_nativerf      s     >

  I
~~*S*:;CNNzzq!3::--#'(>>JJ

 233::9,

#**i@S@ST  

CJJ''#t4n::s?rV   c                  t        ||j                         j                        r.t        |      x}t        |       x}k7  rd| d| }t	        |      |t
        j                  u r| j                  d      } || _        | S |t
        j                  u r0d|j                         cxk  rdk  rn n| j                  |dd      S | j                  |d	      S )
z}Wrapper around pandas' set_axis to set object index.

    We can set `copy` / `inplace` based on implementation/version.
    zExpected object of length z, got length: F)deep         r   )axiscopy)rn   )r\   to_native_namespaceIndexlenr   r   CUDFro   rZ   rP   _backend_versionset_axis)objrZ   rS   expected_len
actual_lenre   s         rT   r^   r^      s     %;;=CCDE
"C
 *J" +<.zlSo,,,hhEh"	
....113:d:||E|66<<A<&&rV   c                   |t         j                  u r*|j                         dk\  r | j                  |i |ddi}n | j                  |i |ddd}t	        d|      S )zXWrapper around pandas' rename so that we can set `copy` based on implementation/version.rl   inplaceF)ro   rz   r'   )r   rP   rt   renamer	   )rv   rS   argskwargsresults        rT   r{   r{      sg     ...'')T1T;V;U;TGVG%G &))rV      )maxsizec                N   t        |       }|j                  }|dv r|j                         S |dv r|j                         S |dv r|j	                         S |dv r|j                         S |dv r|j                         S |dv r|j                         S |dv r|j                         S |dv r|j                         S |d	v r|j                         S |d
v r|j                         S |dv r|j                         S |dv r|j                         S |j                  d      r|j                         S |dk(  rt!        | |      S t"        j%                  |      x}st&        j%                  |      x}r4|j)                  d      }|j)                  d      }|j+                  ||      S t,        j%                  |      x}st.        j%                  |      x}r"|j)                  d      }|j1                  |      S |dk(  r|j3                         S |j                  d      r!|j5                  d      r|j7                         S |j                  d      r!|j5                  d      r|j9                         S |j                  d      r!|j5                  d      r|j;                         S |j=                         S )N>   int64[pyarrow]Int64int64Int64[pyarrow]>   int32[pyarrow]Int32int32Int32[pyarrow]>   int16[pyarrow]Int16int16Int16[pyarrow]>   int8[pyarrow]Int8int8Int8[pyarrow]>   uint64[pyarrow]UInt64uint64UInt64[pyarrow]>   uint32[pyarrow]UInt32uint32UInt32[pyarrow]>   uint16[pyarrow]UInt16uint16UInt16[pyarrow]>   uint8[pyarrow]UInt8uint8UInt8[pyarrow]>   double[pyarrow]float64[pyarrow]Float64float64Float64[pyarrow]>   float[pyarrow]float32[pyarrow]Float32float32Float32[pyarrow]>   string[python]large_string[pyarrow]string[pyarrow_numpy]strstringstring[pyarrow]>   bool[pyarrow]rM   booleanboolean[pyarrow]zdictionary<category	time_unit	time_zonezdate32[day][pyarrow]decimalz	[pyarrow]timebinary)r   dtypesr   r   r   r   r   r   r   r   r   r   StringBoolean
startswithCategorical$native_categorical_to_narwhals_dtypePATTERN_PD_DATETIMEmatchPATTERN_PA_DATETIMEgroupDatetimePATTERN_PD_DURATIONPATTERN_PA_DURATIONDurationDateendswithDecimalTimeBinaryUnknown)native_dtypeversiondtyper   match_dt_time_unitdt_time_zonedu_time_units           rT   #non_object_native_to_narwhals_dtyper      s   E^^FFF||~FF||~FF||~BB{{}JJ}}JJ}}JJ}}FF||~   ~~   ~~   }}HH~~&!!##
3L'JJ%++E222%++E222!'k!:#)<<#<|\::%++E222%++E222!'k!:|,,&&{{}	"u~~k'B~~ENN;$?{{}!enn[&A}}>>rV   c                   |j                   }|t        j                  u r|j                         S t        j
                  j                  j                  }| dn || j                  d      d      }|dk(  r|j                         S |dk(  r"|t        j                  ur|j                         S |dk(  r|j                         S |j                         S )Nemptyd   T)skipnar   )r   r   rs   r   pdapitypesinfer_dtypeheadr   V1Object)seriesr   rS   r   inferinferred_dtypes         rT   object_native_to_narwhals_dtyper      s     ^^F,,, }}FFLL$$E &WE&++c:JSW4XN!}} WGJJ%>}} }}==?rV   c                0   |j                   }|t        j                  u r|j                         S | j                  rM|t
        j                  u rt        |       n| j                  j                  }|j                  t        |            S |j                         S rO   )r   r   r   r   orderedr   rs   _cudf_categorical_to_list
categoriesto_listEnumr   )r   r   rS   r   	into_iters        rT   r   r   7  s    
 ^^F'**!!## !4!44 &l3((00 	
 {{,Y788rV   c                     d fd}|S )Nc                 T     j                   j                         j                         S rO   )r   to_arrow	to_pylist)r   s   rT   fnz%_cudf_categorical_to_list.<locals>.fnM  s!    &&//1;;==rV   )returnz	list[Any] )r   r   s   ` rT   r   r   I  s    > IrV   F)allow_objectc                  t        |       }|j                  d      r<ddlm} t	        | d      r || j                         |      S  || j                  |      S |dk(  r+|j                         rt        | |t        j                        S |dk7  rt        | |      S |t        j                  u r|j                  j                         S |rt        d ||      S d}t!        |      )N)
large_listr`   structfixed_size_listr   )native_to_narwhals_dtyper   r   objectz;Unreachable code, object dtype should be handled separately)r   r   narwhals._arrow.utilsr   hasattrr   pyarrow_dtypeis_cudfr   r   rs   r   DASKr   r   r   AssertionError)r   r   rS   r   	str_dtypearrow_native_to_narwhals_dtypere   s          rT   r   r   S  s     L!IOP	
 <,1,2G2G2I7SS-l.H.H'RRJ>#9#9#; 4'>#6#6
 	
 H2<II,,, ~~$$&&.tWnMME  
rV   )rj      c                    t               }t        | t        j                  j                  j
                        xr t        | d|      du S )z/Return `True` if `dtype` is `"numpy_nullable"`.baseN)r   r\   r   r   
extensionsExtensionDtypegetattr)r   sentinels     rT   is_dtype_numpy_nullabler
  {  s@     8ubff//>>? 9vx0D8	
rV   c                    t        | t        j                  j                  j                        rddlm} t        | |      S y)Nr   r   F)r\   r   r   r  r  pandas.core.arrays.maskedr   )r   OldBaseMaskedDtypes     rT   r
  r
    s6     eRVV..==> e%788rV   c                ^    |t         j                  u ryt        |       ryt        |       rdS dS )zjGet dtype backend for pandas type.

    Matches pandas' `dtype_backend` argument in `convert_dtypes`.
    Npyarrownumpy_nullable)r   rs   is_dtype_pyarrowr
  )r   rS   s     rT   get_dtype_backendr    s3    
 ,,,6u=G4GrV   c                    fd| D        S )ziYield a `DTypeBackend` per-dtype.

    Matches pandas' `dtype_backend` argument in `convert_dtypes`.
    c              3  6   K   | ]  }t        |        y wrO   )r  ).0r   rS   s     rT   	<genexpr>z&iter_dtype_backends.<locals>.<genexpr>  s     Ie^4Is   r   )r   rS   s    `rT   iter_dtype_backendsr    s     J&IIrV   c                Z    t        t        d      xr t        | t        j                        S )N
ArrowDtype)r   r   r\   r  r   s    rT   r  r    s    2|$IE2==)IIrV   r   r   zMapping[type[DType], str]NW_TO_PD_DTYPES_INVARIANTr   r   r   )r  r  Nr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   z<Mapping[type[DType], Mapping[DTypeBackend, str | type[Any]]]NW_TO_PD_DTYPES_BACKENDc                   |dvrd| d}t        |      |j                  }| j                         }t        j	                  |      x}r|S t
        j	                  |      x}r||   S t        | |j                        rt        |      rxt        dk  rot        | |j                        rV| j                  dk7  rGt        j                  t              }	d|	d}
d}d	| j                  d
|
 d| d}t        |t               d}n| j                  }|dk(  r| j                   x}rd| nd}d| | dS | j                   x}rd| nd}d| | dS t        | |j"                        r4t        |      rt        dk  rd}n| j                  }|dk(  rd| dS d| dS t        | |j$                        r	 dd l}yt        | |j*                        ro|t,        j.                  u rd}t1        |      t        | |j*                        r-|j3                         }|j5                  | j6                  d      S d}t        |      t9        ||j:                  |j<                  |j>                  |j@                  |jB                  f      rtE        | ||      S t9        |tF              rd|jH                   d| d}t1        |      d |  }tK        |      # t(        $ r}d}t)        |      |d }~ww xY w)!N>   Nr  r  z;Expected one of {None, 'pyarrow', 'numpy_nullable'}, got: '')r  rK   z*available in 'pandas>=2.0', found version .zhttps://pandas.pydata.org/docs/dev/whatsnew/v2.0.0.html#construction-with-datetime64-or-timedelta64-dtype-with-unsupported-resolutionz`nw.Datetime(time_unit=z)` is only z
Narwhals has fallen back to using `time_unit='ns'` to avoid an error.

Hint: to avoid this warning, consider either:
- Upgrading pandas: zA
- Using a bare `nw.Datetime`, if this precision is not importantr  z, tz= z
timestamp[z
][pyarrow]z, zdatetime64[]z	duration[ztimedelta64[r   z/'pyarrow>=13.0.0' is required for `Date` dtype.zdate32[pyarrow]z9Converting to Enum is not supported in narwhals.stable.v1T)r   z9Can not cast / initialize Enum without categories presentConverting to z dtype is not supported for zUnknown dtype: )&
ValueErrorr   	base_typer  getr  r   r   rU   PANDAS_VERSIONr\   r   r   _unparse_versionr   UserWarningr   r   r   r  ModuleNotFoundErrorr   r   r   NotImplementedErrorrp   CategoricalDtyper   
issubclassStructArrayListr   r   narwhals_to_native_arrow_dtypeUNSUPPORTED_DTYPES__name__r   )r   dtype_backendrS   r   re   r   r$  pd_typeinto_pd_typefound	availablechangelog_urlr   tztz_partr   paexcrK   s                      rT   narwhals_to_native_dtyper=    s'    ??Mm_\]^o^^F!I+//	::w:.229==|=M**v7n-. D
 3
 %1eoo6M 11.AH	QRS	 !h-eoo-@I; W+ ,9/ :WX  c;/L ??LI%-2__'<r'<bTl2G~gYjAA&+oo 5 5Brd)B\N7)155v7n-. D
 3
  L ??L 	) ~Z0	
  ~Q/	

  v{{3	4 
 !v{{3gjj MC%c**eV[[)335B&&u'7'7&FFIoFMM6<<fkk6==Y .e^WMM)/0y1122N~N^^_`!#&&E7
#C

- # 	4CC%c*3	4s   ,K 	K KK c                   t        |      r0t        dk\  r'	 dd l}ddlm} t        j                   || |            S d|  d| d| d	}t        |      # t        $ r#}d|  d|j                   }t        |      |d }~ww xY w)
N)r  r  r   zUnable to convert to z  to to the following exception: )r=  r"  z+ dtype is not supported for implementation z and version r  )
rU   r&  r  ImportErrorre   r   r=  r   r  r*  )r   rS   r   r;  r<  re   _to_arrow_dtypes          rT   r0  r0  2  s     .)n.F	,  	V}}_UG<==
J
-y	3  c
""  	,)%0PQTQXQXPYZCc"+	,s   A 	A?A::A?c                l    dt        |       v ryt        |       j                         t        |       k7  ryy)Nr  r   r   r   )r   lowerr  s    rT   int_dtype_mapperrC  E  s0    CJ
5zSZ'rV   i  i@B )	)rK   rJ   )rK   rI   )rJ   rK   )rJ   rI   )rI   rK   )rI   rJ   )rH   rK   )rH   rJ   )rH   rI   zGMapping[tuple[UnitCurrent, UnitTarget], tuple[BinOpBroadcast, IntoRhs]]_TIMESTAMP_DATETIME_OP_FACTORc                    ||k(  r| S t         j                  ||f      x}r|\  }} || |      S d| d}t        |      )Nzunexpected time unit zD, please report an issue at https://github.com/narwhals-dev/narwhals)rD  r%  r   )rH   currentr   itemr   factorre   s          rT   calculate_timestamp_datetimerI  \  sd     ),00'91EFFtF
F!V}
y )3 	3  
rV   rj   )rK   rJ   rI   rH   zMapping[TimeUnit, int]_TIMESTAMP_DATE_FACTORc                (    | t         z  t        |   z  S rO   )r   rJ  )rH   r   s     rT   calculate_timestamp_daterL  s  s    !7	!BBBrV   c                   t        |      | j                  d   k(  r| j                  |k(  j                         r| S | j                  j                  j
                  dk(  s%|t        j                  u rO|j                         dk  r<t        || j                  j                               x}r|| j                  dd|f   S 	 | |   S # t        $ r0}t        || j                  j                               x}r|| d}~ww xY w)zsSelect columns by name.

    Prefer this over `df.loc[:, column_names]` as it's
    generally more performant.
    rj   bri   )r7  N)rr   shapecolumnsallr   kindr   rP   rt   r   tolistlocKeyError)dfcolumn_namesrS   errores        rT   select_columns_by_namerZ  w  s     <BHHQK'RZZ<-G,L,L,N	


$.///++-6 (

@Q@Q@STT5TKvvao&&, '

@Q@Q@STT5TQs    C 	C>+C99C>c                    | j                   t        j                  t        j                  t        j                  hv xr | j
                  j                  dk(  S )NrM   )r_   r   rP   rQ   r   rY   r   )rH   s    rT   is_non_nullable_booleanr\    sI     	
!!>#7#79L9LM	N 	%HHNNf$rV   c                   | t         j                  t         j                  hv rddl}|S | t         j                  u rddl}|S d|  }t        |      )zCReturns numpy or cupy module depending on the given implementation.r   Nz!Expected pandas/modin/cudf, got: )r   rP   rQ   numpyrs   cupyr   )rS   npcpre   s       rT   import_array_modulerb    sQ    .//1E1EFF	,,,	-n-=
>C

rV   c                      e Zd Zy)PandasLikeSeriesNamespaceN)r2  
__module____qualname__r   rV   rT   rd  rd    s    rV   rd  )rS   r   r   rM   )rb   r%   rc   zPandasLikeSeries | objectr   z7tuple[pd.Series[Any] | object, pd.Series[Any] | object])rv   r'   rZ   r   rS   r   r   r'   )
rv   r'   r|   r   rS   r   r}   r   r   r'   )r   r   r   r   r   r)   )r   zPandasLikeSeries | Noner   r   rS   r   r   r)   rO   )r   zpd.CategoricalDtyper   r   rS   z#Literal[Implementation.CUDF] | Noner   r)   )r   r   r   zCallable[[], list[Any]])
r   r   r   r   rS   r   r   rM   r   r)   )r   r   r   zTypeIs[BaseMaskedDtype])r   r   rS   r   r   r*   )r   zIterable[Any]rS   r   r   zIterator[DTypeBackend])r   r   r   zTypeIs[pd.ArrowDtype])
r   r+   r3  r*   rS   r   r   r   r   zstr | PandasDtype)r   r+   rS   r   r   r   r   zpd.ArrowDtype)r   r   r   r   )rH   r(   rF  r,   r   r,   r   r(   )rH   r(   r   r,   r   r(   )rV  r&   rW  zlist[str] | _1DArrayrS   r   r   zNativeDataFrameT | Any)rH   r%   r   rM   )rS   r   r   r   )
__future__r   	functoolsoperatorretypingr   r   r   r   r   r	   pandasr   narwhals._compliantr
   narwhals._constantsr   r   r   r   r   r   narwhals._exceptionsr   narwhals._utilsr   r   r   r   r   r   narwhals.exceptionsr   collections.abcr   r   r   r   r   pandas._typingr   PandasDtypepandas.core.dtypes.dtypesr   typing_extensionsr    r!   narwhals._durationr"   narwhals._pandas_like.exprr#   rX   r%   narwhals._pandas_like.typingr&   r'   r(   narwhals.dtypesr)   narwhals.typingr*   r+   r,   r-   r.   r0   __annotations__r1   intr2   r3   rP   rs   rQ   PANDAS_LIKE_IMPLEMENTATIONPD_DATETIME_RGXcompileVERBOSEr   PA_DATETIME_RGXr   PD_DURATION_RGXr   PA_DURATION_RGXr   r?   
ALIAS_DICTrL   rt   r&  rU   rf   r^   r{   	lru_cacher   r   r   r   r   r
  r  r  r  MAINr   r   r   r  r   r   r   r   r   r   r   r   r   r   r   r   r   r  r   r1  r=  r0  rC  floordivmulrD  rI  rJ  rL  rZ  r\  rb  rd  r   rV   rT   <module>r     s5   "   	 G G  4  /  +;; 393/9= 
 &KKG>2E%K%$J	$ (#sS 9NI9GY  
 !bjj"**=  !bjj"**=  !bjj"**=  !bjj"**=  '
! I  U#
		
				


9
5   &&779K	 9<@'	' #'8F''.
*	
* #
*5C
*OR
*
* R G !GT#.5GU
4 ;? %   8  	 $ ### ##
 # #L ))+v5
	HJJ+9JJ R J !J 
		
 

MM88 4  NN%#
 NN%#
 LL.'QXY
LL.'QXY
LL.'QXY
KK_fU
MM$"
 MM$"
 MM$"
 LL.'QXY
MM0HTWX
NN%#A%Y U %L nn& MMM #M 	M
 M`##&4#?F##& $$e,$$i0<<!34$$e,<<!34<<',,.,,.,,.
    '4<  

	
	2 . C& # 	: T 45G5L M SrV   