
    bie              	      6   U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlmZm	Z	m
Z
mZ d dlmZ d dlmZ d dlmZmZmZ d dlZd dlZd dlmZ d dlZd dlmZ d d	lmZ d d
lm Z m!Z! d dl"m#Z#m$Z$m%Z%m&Z& d dl'm(Z( d dl)m*Z*m+Z+ d dl,m-Z-m.Z.m/Z/m0Z0m1Z1 ejd                  ejf                  ejh                  ejj                  fZ6de7d<   	 d dl8m9Z: e6e:jv                  fz  Z6d Z=d Z>d Z?dZ@dZA ede      ZBedBd       ZCedCd       ZCd ZCedDd       ZDdZEd ZFdEdZGdFd ZHdGd!ZI ej                  d       ej                  d"       ej                  d#       ej                  d$       ej                  d%       ej                  d%       ej                  d%      d&ZOd'e7d(<    eP       ZQe reQeOd)<   nd%eOd)<   d* ZRd+ ZSdHd,ZTd- ZUdGd.ZVdId/ZWdJd0ZXd1 ZYd2 ZZ	 	 	 	 	 	 dKd3Z[d4 Z\dGd5Z]d6 Z^dLd7Z_dLd8Z`d9 ZadMd:Zb G d; d<eced      Zed= Zfd> Zgd? ZhdNd@ZidOdAZjy# e<$ r Y Aw xY w)P    )annotationsN)CallableIterableMappingSequence)contextmanager)Number)AnyTypeVaroverload)is_dtype_equal)is_dask_collection)get_deps)PANDAS_GE_300tm)is_categorical_dtype_dispatch	make_metamake_meta_objmeta_nonempty)make_scalar)	NoDefault
no_default)
asciitableis_dataframe_likeis_index_likeis_series_liketypenameztuple[type, ...]meta_object_typesc                   t        | t        t        f      rt        | t              syt	        | d      rt        | t
        j                        S t        | t              ryt        | t        t        f      s| yddl	m
} t        | |       S )NFdtypeTr   )Expr)
isinstancer   r   strhasattrnp
ScalarTypedictintdask.dataframe.dask_expr._exprr!   )xr!   s     O/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/dask/dataframe/utils.py	is_scalarr,   .   sm    !h)*:a3E	G	!R]]++!T!c3Z AI3!T"""    c                (   t        | d|       }t        j                  t        j                  t        j                  t        j
                  t        j                  t        j                  t        j                  t        j                  f}t        ||      S Nr    )getattrpd	Int8Dtype
Int16Dtype
Int32Dtype
Int64Dtype
UInt8DtypeUInt16DtypeUInt32DtypeUInt64Dtyper"   tr    typess      r+   is_integer_na_dtyper=   >   s^    Aw"E







	E eU##r-   c                t    t        | d|       }t        j                  t        j                  f}t	        ||      S r/   )r0   r1   Float32DtypeFloat64Dtyper"   r:   s      r+   is_float_na_dtyperA   M   s4    Aw"E

E eU##r-   z?meta : pd.DataFrame, pd.Series, dict, iterable, tuple, optionala  An empty ``pd.DataFrame`` or ``pd.Series`` that matches the dtypes and
column names of the output. This metadata is necessary for many algorithms
in dask dataframe to work.  For ease of use, some alternative inputs are
also available. Instead of a ``DataFrame``, a ``dict`` of ``{name: dtype}``
or iterable of ``(name, dtype)`` can be provided (note that the order of
the names should match the order of the columns). Instead of a series, a
tuple of ``(name, dtype)`` can be used. If not provided, dask will try to
infer the metadata. This may lead to unexpected results, so providing
``meta`` is recommended. For more information, see
``dask.dataframe.utils.make_meta``.
T)boundc                     y N )funcs    r+   insert_meta_param_descriptionrH   g   s    14r-   c                     y rE   rF   )pads    r+   rH   rH   k   s    ADr-   c                    | sfdS | d   }dj                  dd      z  }t        j                  t        ||d      }dj	                  t
        d	j                  |            }|j                  rd
|j                  v r#|j                  j                  d
|      |_        |S d|dd z  }t        j                  d|j                        \  }}|j                  dd      \  }	}
dj	                  |||	|dd ||
      |_        |S )zReplace `$META` in docstring with param description.

    If pad keyword is provided, will pad description by that number of
    spaces (default is 8).c                    t        | fi S rE   )rH   )fkwargss    r+   <lambda>z/insert_meta_param_description.<locals>.<lambda>u   s    6qCFC r-   r    rJ      N   )initial_indentsubsequent_indentwidthz{}
{}
z$METAzParameters
%s----------   NzParameters\n[ ]*----------z

   z{}{}{}
{}{}

{})gettextwrapwrap_META_DESCRIPTIONformat_META_TYPESjoin__doc__replaceresplit)argsrN   rM   indentbodydescrparameter_headerfirstlast
parametersrests    `         r+   rH   rH   o   s    
 CCQA6::eQ''F==&FRTD OOK49Eyyaii		))'59AI H  :F12JF((#@!))LKE4#zz&!4J,33'VABZAI Hr-   c              #  ,  K   	 d y# t         $ r}t        j                         \  }}}dj                  t	        j
                  |            }d}|r|dz  }|dz  }|j                  | rd|  dndt        |      |      }t        |      |d}~ww xY ww)zReraise errors in this block to show metadata inference failure.

    Parameters
    ----------
    funcname : str, optional
        If provided, will be added to the error message to indicate the
        name of the method that failed.
    N zMetadata inference failed{0}.

zYou have supplied a custom function and Dask is unable to 
determine the type of output that that function returns. 

To resolve this please provide a meta= keyword.
The docstring of the Dask function you ran should have more information.

zOOriginal error is below:
------------------------
{1}

Traceback:
---------
{2}z in ``)		Exceptionsysexc_infor_   	traceback	format_tbr]   repr
ValueError)funcnameudfeexc_type	exc_valueexc_tracebacktbmsgs           r+   raise_on_meta_errorr      s     % %-0\\^*)]WWY((781_C 		
 jj5
!,b$q'2No1$)%s%   B	 B	BA:BBB__UNKNOWN_CATEGORIES__c                    t        | d|       } t        |       rt        | j                  j                  vS t        |       rt        | d      rt        | j                  vS t        d      )zwReturns whether the categories in `x` are known.

    Parameters
    ----------
    x : Series or CategoricalIndex
    _meta
categoriesz#Expected Series or CategoricalIndex)r0   r   UNKNOWN_CATEGORIEScatr   r   r$   	TypeError)r*   s    r+   has_known_categoriesr      s[     	7AAa!)9)999	q	ga6!55
9
::r-   c                   t        | t        j                  t        j                  f      rv| j	                         } t        | t        j                        r| j
                  dk(  }|j                         r||   j                  }|D ]Y  }t        | |         r|r%| |   j                  j                  t        d       9| |   j                  j                  g       | |<   [ ndt        | t        j                        rJt        | j                  t        j                        r&t        |       s| j                  j                  g       } t        | j                  t        j                        r5t        | j                        s | j                  j                  g       | _        | S t        | t        j                        rt        |       s| j                  g       } | S )zReplace any unknown categoricals with empty categoricals.

    Useful for preventing ``UNKNOWN_CATEGORIES`` from leaking into results.
    categoryT)inplace)r"   r1   Series	DataFramecopydtypesanyindexr   r   remove_categoriesr   set_categoriesr    CategoricalDtypeCategoricalIndex)r*   just_drop_unknowncat_maskcatscs        r+   strip_unknown_categoriesr      sd   
 !bii./FFHa&xx:-H||~)// ?A/!5,aDHH667ISW6X#$Q488#:#:2#>AaD? 299%!''2#6#67@TUV@WEE((,aggr223<PGG=
 gg,,R0AG H 
Ar**	+4H4KR Hr-   Tc                   |dk(  r| S t        |       s| j                         } t        |       rw| j                  dk(  }|||   j                  }n(|j
                  |   j                         st        d      |D ](  }| |   j                  j                  t        g      | |<   * n@t        |       r5t        | j                        r | j                  j                  t        g      } |rDt        | j                  j                        r%| j                  j                  t        g      | _        | S t        | j                        r| j                  t        g      } | S )a)  Set categories to be unknown.

    Parameters
    ----------
    x : DataFrame, Series, Index
    cols : iterable, optional
        If x is a DataFrame, set only categoricals in these columns to unknown.
        By default, all categorical columns are set to unknown categoricals
    index : bool, optional
        If True and x is a Series or DataFrame, set the clear known categories
        in the index as well.
    dtype_backend : string, optional
        If set to PyArrow, the categorical dtype is implemented as a PyArrow
        dictionary
    pyarrowr   z Not all columns are categoricals)r   r   r   r   r   locallrv   r   r   r   r   r   r    )r*   colsr   dtype_backendmaskr   s         r+   clear_known_categoriesr      s(     	! FFHQ88z)D|Dz''XXd^'') !CDD Etxx..0B/CD!EA,QWW5EE((*<)=>2177==Agg,,.@-ABAG H 
'qww	/012Hr-   c                    t        |t              rU|dk(  rPt        j                  t        j                  t
        g      |       j                  d d }|t        |      |_        |S t        j                  g || |      S )Nr   )namer   )r    r   r   )	r"   r#   r1   r   Categoricalr   ilocr   r   )r   r    r   ss       r+   _empty_seriesr     si    %%:"5IIbnn&8%9:FKKBQO&AG99Ru4u==r-       z
1970-01-01rX   foo)bVMmSaUzdict[str, Any]_simple_fake_mappingOc                <   | j                   dv r| j                  d      S | j                   dk(  r| j                  t        dd            S | j                   t        v r4t        | j                      }| j                   dv r|j	                  |       S |S t        d|        )N)irM   urX   r   r   )r   r   zCan't handle dtype: )kindtypecomplexr   astyper   )r    os     r+   _scalar_from_dtyper      s    zz_$zz!}	s	zz'!Q-((	+	+ ,"'**
":qxxAA.ug677r-   c                   t        |       t        j                  v rt        |       S t        j                  |       rAt        | d      r| j                  nt        j                  t        |             }t        |      S | t        j                  u rt        j                  S t        dt        t        |              d      )Nr    zCan't handle meta of type '')r   r   _lookupr%   isscalarr$   r    r1   NAr   r   )r*   r    s     r+   _nonempty_scalarr   ,  s    Aw+%%%1~	{{1~"1g.BHHT!W4E5!!BEEzuu
1(472C1DAF
GGr-   c           	        |rh dn	t               fd}t        |      st        |      st        |      rt	        |      r t        dt        t        |            z        | j                  |j                  k7  r8dj                  t        t        |            t        t        |                   }n,t        |      rt        j                  | j                  |j                  gdd      }|j                  d      j                         D 	cg c]  \  }}}	 |||	      st        |      ||	f }
}}}	|
r1d	j                  t        t        |            t!        g d
|
            }nwt#        ||        | S  || j$                  |j$                        r| S d	j                  t        t        |            t!        ddgd| j$                  fd|j$                  fg            }t'        d|rd|z  ndd|      c c}	}}w )a  Check that the dask metadata matches the result.

    If metadata matches, ``x`` is passed through unchanged. A nice error is
    raised if metadata doesn't match.

    Parameters
    ----------
    x : DataFrame, Series, or Index
    meta : DataFrame, Series, or Index
        The expected metadata that ``x`` should match
    funcname : str, optional
        The name of the function in which the metadata was specified. If
        provided, the function name will be included in the error message to be
        more helpful to users.
    numeric_equal : bool, optionl
        If True, integer and floating dtypes compare equal. This is useful due
        to panda's implicit conversion of integer to floating upon encountering
        missingness, which is hard to infer statically.
       rM   r   r   c                   t        | t        j                        t        |t        j                        k7  ryt        | t              r| dk(  st        |t              r|dk(  ryt        | t        j                        rDt        |t        j                        r*t        | j
                  v st        |j
                  v ry| |k(  S | j                  v xr |j                  v xs t        | |      S )NF-T)r"   r1   r   r#   r   r   r   r   )r   r   eq_typess     r+   equal_dtypesz check_meta.<locals>.equal_dtypesP  s    a,,-Ar?R?R1SSa!s(jC.@Q#Xa,,-*Q@S@S2T!Q\\15G1<<5W6M("9qvv'9RnQPQ>RRr-   z>Expected partition to be DataFrame, Series, or Index, got `%s`z,Expected partition of type `{}` but got `{}`rX   T)axissortr   zPartition type: `{}`
{})ColumnFoundExpectedrn   r    r   r   zMetadata mismatch foundz in `%s`z.

)setr   r   r   r   r   r   r   	__class__r]   r1   concatr   fillna
itertuplesru   r   check_matching_columnsr    rv   )r*   metarw   numeric_equalr   errmsgr   colr   r   
bad_dtypesr   s              @r+   
check_metar   :  s   ( #0SUH	S 	$>$#7=;N	D	! (d 45
 	
 	{{dnn$?FFT$Z T!W
 
4	 AHHdkk2F $]]3/::<
 
Q1% #Y1

 

 /66d$:JGF
 #4+H,H+22T$Z G}'9J

;S&TU

 *2h&:V	E +
s   "G8c                ,   dd l mc m} t        j                  t        j
                  | j                        t        j
                  |j                              s|j                  |j                  j                  | j                              }|j                  | j                  j                  |j                              }|s|r	d| d| }n8d|j                  j                          d| j                  j                          }t        d|       y )Nr   z  Extra:   z
  Missing: z+Order of columns does not match.
Actual:   z
Expected: zTThe columns in the computed data do not match the columns in the provided metadata.
)
dask.dataframe.methods	dataframemethodsr%   array_equal
nan_to_numcolumnstolist
differencerv   )r   actualr   extramissing
extra_infos         r+   r   r     s    ,, >>"--5r}}V^^7TUv~~88FG..!8!8!HIG&ug]7)DJ%~~4467t||22457 
 7l
 	
 Vr-   c                    t        |       }|| j                  j                  }|r| d   }| d   }d| d| }nd}| d| d| S )z&Summarized representation of an Index.r   z, z to rn   z: z entries)lenr   __name__)idxr   nheadtailsummarys         r+   index_summaryr     sb    CA|}}%%1v2wtfD'V2aS	**r-   c                H   dd l m} t        | d      r| j                         }t        |d      r|j	                          || j                  |      }t        | |j                        st        | j                        rdt        |      j                  v sJ t        |             |r| j                  |j                  k(  sJ | j                  j                  |j                  k(  sJ t        |t        j                        r%|j                  | j                  j                  k(  sJ |rt!        | |       |S t        | |j"                        st%        | j                        rdt        |      j                  v sJ t        |             t        | j                        t        |      k(  sJ t        | j                               |r[| j                  |j                  k(  sJ | j                  |j                  f       | j                  j                  |j                  k(  sJ |rt!        | |       t'        | j(                  |||j(                         |S t        | |j*                        st-        | j                        r3dt        |      j                  v sJ t        |             t        | j.                  t        j                        sJ t        | j.                               t        | j                        t        |      k(  sJ t        | j                               |r^t1        j2                  | j.                  |j.                         t1        j2                  | j                  j.                  |j.                         |rt!        | |       t'        | j(                  |||j(                         |S t5        j6                  |      sJt        |t        j8                  t        j:                  f      s t=        d	t?        t        |            z         |rt!        | |       |S | S )
Nr   __dask_graph__validate	schedulerIndexr   )check_namescheck_dtypesresultr   zFExpected object of type dataframe, series, index, or scalar.
    Got: ) dask.dataframer   r$   r   r   computer"   r   r   r   r   r   r   r1   
MultiIndexnamesassert_dask_dtypesr   r   _check_daskr   r   r   r   r   assert_index_equalr%   r   	Timestamp	Timedeltar   r#   )dskr   r   r   r   ddgraphs          r+   r   r     s"   s$%""$5*%NN>[[9[5Fc288$cii(@d6l333AT&\A3xx6;;...yy~~444fbmm4!<<399??:::"3/P O RYY'>#))+DtF|444Bd6lB4		?d6l2CDOC2xx6;;.G6;;0GG.yy~~444"3/		')||	> 3 R\\*.?		.J$v,"7"77EfE7ckk2884Gd3;;6GG4		?d6l2CDOC2%%ckk6>>B%%cii&7&7H"3/		')||	   ;;v&zr||40   "%d6l"34  "3/Jr-   c                   dd l mc m} 	 t        |       rt	        | j
                  j                        t	        | j                        z  rHt        t        | j
                  j                              D cg c]  }d|z  	 c}| j
                  _        | j                  |j                  | j                              } n| j                         } |r| j                         S | S c c}w # t        t        t        f$ r Y /w xY w)Nr   z-overlapped-index-name-%d)by)r   r   r   r   r   r   r   r   ranger   sort_valuesr   r   
IndexErrorrv   
sort_index)r   check_indexr   r   s       r+   _maybe_sortr    s    ,,
Q177==!C		N2=B3qww}}CU=V!89/!3! 		!:;AA )1<<>/a/! z:. s%   A*C( 5C#AC( #C( (C?>C?c                .   t               rddlm} t        | t        j
                  t        j                  t        j                  f      r ||       } t        |t        j
                  t        j                  t        j                  f      r ||      }| |fS )Nr   )to_pyarrow_string)pyarrow_strings_enableddask.dataframe._pyarrowr  r"   r1   r   r   r   )r   r   r  s      r+   _maybe_convert_stringr    sb     =a",,		288<=!!$Aa",,		288<=!!$Aa4Kr-   c                    t        | |      \  } }t        j                  | j                  j	                         |j                  j	                                y rE   )r  r   assert_series_equalr   value_counts)r   r   s     r+   assert_eq_dtypesr    s<     A&DAq188002AHH4I4I4KLr-   c                   |rt        | |       t        ||       t        | d      rt        |d      rt        t        j                  | j
                        j                         d         }	t        t        j                  |j
                        j                         d         }
|	|
k(  s	J |	|
f       t        |        t        |       t        | |||      } t        ||||      }t        | d      r| j                         } t        |d      r|j                         }t        | |      \  } }t        | t        j                  t        j                  f      r|rt        | |      } t        ||      }|s$| j!                  d      } |j!                  d      }t        | t        j                        rt#        j$                  | |f||d| yt        | t        j                        rt#        j&                  | |f||d| yt        | t        j(                        rt#        j*                  | |fd	|i| y| |k(  ryt        j,                  |       rt        j,                  |      sJ yt        j.                  | |      sJ y)
Nr   	divisionsr   )r   r   r   	to_pandasT)drop)r   check_dtypeexact)assert_divisionsr$   r   r%   asarrayr  r   assert_sane_keynamesr   r  r  r"   r1   r   r   r  reset_indexr   assert_frame_equalr  r   r   isnanallclose)r   r   r   r  check_divisionsr  sort_resultsr   rN   atbts              r+   	assert_eqr'    s;    i0i01k"wq+'>bjj-446q9:Bbjj-446q9:B8%b"X%8	{		A 		{		A q+KKMq+KKM A&DAq!bllBII./L;';'MMtM$MMtM$!R\\"
q	
){	
FL	
"  
Aryy	!
q	
){	
FL	
  
Arxx	 
a@+@@  6xx{xx{"{  {{1a(((r-   c                    t        | d      r| j                  } t        | t              sJ | D ]*  }t        |t              r|d   }|j                  |      s* y t        d|       )Ndaskr   Tz(given dask graph doesn't contain label: )r$   r)  r"   r   tuple
startswithAssertionError)r)  labelks      r+   assert_dask_graphr/  O  sk    tVyydG$$$ a!A<<	
 CE7K
LLr-   c                    t        | d      sy t        | j                  t              sJ t	        | dd      sy | j                         j                  |       y )Nr  known_divisionsFr   )r$   r"   r  r*  r0   enforce_runtime_divisionsr   )ddfr   s     r+   r  r  [  sM    3$cmmU+++3)51!!#++i+@r-   c                f   t        | d      r| j                         }|j                         }|D ]  }t        |t              r|d   }t        |t              rt        |t
        t        f      sJ t        |      dk  sJ d|vsJ |j                  d      d   j                         rzJ |        y y )Nr   r   d   rP   r   )
r$   optimizer   r"   r*  r#   bytesr   rc   isidentifier)r3  r  r.  s      r+   r  r  g  s    s$%lln  " 	5AQ&aD Q&a#u...q6C<<a<<773<?//14141	5 &r-   c                   h dg|rj                  h d       fd}t        |      sft        |      r[t        j                  | j
                  j                  |j                  gd      j                  d      D ]  \  }} |||      rJ  y	t        |      sDt        |      st        |      r.| j
                  j                  }|j                  } |||      sJ y	t        | j
                  d      rp| j
                  j                  }t        |d      s6t        j                  |      sJ t        j                  t        |            }n|j                  } |||      sJ y	t        | j
                        t        |      k(  sJ y	)
a  Check that the dask metadata matches the result.

    If `numeric_equal`, integer and floating dtypes compare equal. This is
    useful due to the implicit conversion of integer to floating upon
    encountering missingness, which is hard to infer statically.>   r   r   r   r   r   c                @     t         fdD              xs  k(  S )Nc              3  Z   K   | ]"  }j                   |v xr j                   |v  $ y wrE   )r   ).0r   r   r   s     r+   	<genexpr>z8assert_dask_dtypes.<locals>.eq_dtypes.<locals>.<genexpr>  s0      
:BAFFh5166X#55
s   (+)r   )r   r   eq_type_setss   ``r+   	eq_dtypesz%assert_dask_dtypes.<locals>.eq_dtypes  s)     
FR
 
 1f	r-   rX   )r   F)r   r    N)appendr   r   r1   r   r   r   r   r   r   r    r$   r%   r   r   )r3  resr   r?  r   r   r>  s         @r+   r   r   t  s@    ))LO,
 c"'8'=IIsyy//<1EPP Q 
 	#DAq Q?"?	#  $-*<s@SIIOOIIA399g&		A3({{3'''HHT#Y'IIQ?"?		?d3i///r-   c                    t        | j                        \  }}|r-t        t        t        |j                                     |k(  sJ y t        t        t        |j                                     |k  sJ y rE   )r   r)  maxmapr   values)r*   r   eqdependencies
dependentss        r+   assert_max_depsrI    s^    '/L*	3sL//123q8883sL//123q888r-   c                   t        | t        t        f      syt        | t              rt        |       } t        j                  |       j                         ryt        | dd       D ]:  \  }}|| |dz      k\  r yt        |t              s$t        j                  |      s: y | dd D ]*  }t        |t              st        j                  |      s* y | d   | d   k  S )a~  Are the provided divisions valid?

    Examples
    --------
    >>> valid_divisions([1, 2, 3])
    True
    >>> valid_divisions([3, 2, 1])
    False
    >>> valid_divisions([1, 1, 1])
    False
    >>> valid_divisions([0, 1, 1])
    True
    >>> valid_divisions((1, 2, 3))
    True
    >>> valid_divisions(123)
    False
    >>> valid_divisions([0, float('nan'), 1])
    False
    FNrX   r   )
r"   r*  listr1   isnullr   	enumerater	   mathr!  )r  r   r*   s      r+   valid_divisionsrP    s    ( i%/ )U#O		yy!)CR.) 1	!a%  a TZZ]	 rs^ a TZZ] R=IbM))r-   c                    | j                  d      }t        j                  j                  j	                  |      s|g}|j                  |d|       |S )z)Use shallow copy to drop columns in placeF)deepT)r   r   errors)r   r1   apir<   is_list_liker  )dfr   rS  df2s       r+   drop_by_shallow_copyrX    sF    
''u'
C66<<$$W-)HHWd6H:Jr-   c                      e Zd ZdZy)AttributeNotImplementedErrorz&NotImplementedError and AttributeErrorN)r   
__module____qualname__r`   rF   r-   r+   rZ  rZ    s    0r-   rZ  c                N   t        |       r	 | j                  } t        |       r| j                  S t        |       r| j                  S t        |       r| j                         j                  S t        t	        |        d      # t        $ r t        t	        |        d      w xY w)zReturn a serial DataFrame constructor

    Parameters
    ----------
    like :
        Any series-like, Index-like or dataframe-like object.
    z( not supported by meta_frame_constructor)r   r   AttributeErrorr   r   r   _constructorr   _constructor_expanddimr   to_framelikes    r+   meta_frame_constructorrd    s     $	U::D    		***	t	}}+++4:,&NOPP  	UtDzl*RSTT	U   B !B$c                N   t        |       r	 | j                  } t        |       r| j                  S t        |       r| j                  S t        |       r| j                         j                  S t        t	        |        d      # t        $ r t        t	        |        d      w xY w)zReturn a serial Series constructor

    Parameters
    ----------
    like :
        Any series-like, Index-like or dataframe-like object.
    z) not supported by meta_series_constructor)r   r   r^  r   r   r   _constructor_slicedr   r_  r   ra  rb  s    r+   meta_series_constructorrh    s     $	V::D '''		   	t	}}2224:,&OPQQ  	VtDzl*STUU	Vre  c                 L    t               rt        j                  d      S t        S )zHDepending on config setting, we might convert objects to pyarrow stringsr   )r  r1   StringDtypeobjectrF   r-   r+   get_string_dtyperl  	  s    (?(A2>>)$MvMr-   c                 L    t         j                  j                  d      } | d} | S )z4Config setting to convert objects to pyarrow stringszdataframe.convert-stringT)r)  configrY   )convert_strings    r+   r  r    s&    [[__%?@Nr-   c                    | t         u ri S d| iS )Nnumeric_only)r   )rq  s    r+   get_numeric_only_kwargsrr    s    +2O.,1OOr-   )rG   rB   returnrB   )rJ   r(   rs  zCallable[[T], T])NF)F)NTNrE   )NT)TTNN)r  bool)TTTTTsync)T)raise)rs  rt  )rq  zbool | NoDefaultrs  r'   )k
__future__r   rO  rb   rq   rZ   rs   collections.abcr   r   r   r   
contextlibr   numbersr	   typingr
   r   r   numpyr%   pandasr1   pandas.api.typesr   r)  	dask.baser   	dask.corer   dask.dataframe._compatr   r   dask.dataframe.dispatchr   r   r   r   dask.dataframe.extensionsr   dask.typingr   r   
dask.utilsr   r   r   r   r   r   r   r   r   r   __annotations__scipy.sparsesparsespspmatrixImportErrorr,   r=   rA   r^   r\   rB   rH   r   r   r   r   r   r   bool_void
datetime64timedelta64str_r   rk  _objectr   r   r   r   r   r   r  r  r  r'  r/  r  r  r   rI  rP  rX  NotImplementedErrorr^  rZ  rd  rh  rl  r  rr  rF   r-   r+   <module>r     sb   "  	 
   A A %  ) )   +  (  4  2 -  (*yy",,"--&X # X	"++'
# $$ P  Cx  
 4 
 4 
 D 
 D6 % %D . ;:&R> 
$		|	$					( n  ( ' %	8HJZ
,+(;|0$
M 9x	M	A
5#0L9)*X1#6 1Q.R.N
PY  		s    H HH