
    LVf                        d dl Z d dlZd dlmZmZ ej
                  d        Zej
                  d        Zej
                  d        Zej
                  d        Z	 ej
                  ddg	      d
        Z
ej
                  d        Zej
                  d        Zej
                  d        Zej
                  d        Zej
                  d        Zej
                  d        Z ej
                  ddg	      d        Z ej
                  d d d d gg d      d        Z ej
                  ddg	      d        Z ej
                  ddg	      d        Z ej
                  ddg	      d        Z ej
                  ddg	      d         Z ej
                  ddg	      d!        Zej
                  d"        Zej
                  d#efd$       Zy)%    N)Seriesoptionsc                      t         )z3A fixture providing the ExtensionDtype to validate.NotImplementedError     h/var/www/html/software/conda/envs/catlas/lib/python3.12/site-packages/pandas/tests/extension/conftest.pydtyper      
     r	   c                      t         )z
    Length-100 array for this type.

    * data[0] and data[1] should both be non missing
    * data[0] and data[1] should not be equal
    r   r   r	   r
   datar      
     r	   c                 n    | j                   s$| j                  dk(  st        j                  d       t        )z
    Length-100 array in which all the elements are two.

    Call pytest.skip in your fixture if the dtype does not support divmod.
    mzNot a numeric dtype)_is_numerickindpytestskipr   r   s    r
   data_for_twosr      s-     s!2 	)*
r	   c                      t         )zLength-2 array with [NA, Valid]r   r   r	   r
   data_missingr   +   r   r	   r   r   )paramsc                 H    | j                   dk(  r|S | j                   dk(  r|S y)z5Parametrized fixture giving 'data' and 'data_missing'r   r   Nparam)requestr   r   s      r
   all_datar   1   s,     }}	.	( 
)r	   c                       fd}|S )a  
    Generate many datasets.

    Parameters
    ----------
    data : fixture implementing `data`

    Returns
    -------
    Callable[[int], Generator]:
        A callable that takes a `count` argument and
        returns a generator yielding `count` datasets.
    c              3   6   K   t        |       D ]  }  y wN)range)count_r   s     r
   genzdata_repeated.<locals>.genJ   s     u 	AJ	s   r   )r   r&   s   ` r
   data_repeatedr'   :   s      Jr	   c                      t         )z
    Length-3 array with a known sort order.

    This should be three items [B, C, A] with
    A < B < C

    For boolean dtypes (for which there are only 2 values available),
    set B=C=True
    r   r   r	   r
   data_for_sortingr)   Q   s
     r	   c                      t         )z{
    Length-3 array with a known sort order.

    This should be three items [B, NA, A] with
    A < B and NA missing.
    r   r   r	   r
   data_missing_for_sortingr+   _   r   r	   c                  "    t         j                  S )z
    Binary operator for comparing NA values.

    Should return a function of two arguments that returns
    True if both arguments are (scalar) NA for your type.

    By default, uses ``operator.is_``
    )operatoris_r   r	   r
   na_cmpr/   j   s     <<r	   c                     | j                   S )z>The scalar missing value for this type. Default dtype.na_value)na_valuer   s    r
   r1   r1   w   s     >>r	   c                      t         )z
    Data for factorization, grouping, and unique tests.

    Expected to be like [B, B, NA, NA, A, A, B, C]

    Where A < B < C and NA is missing.

    If a dtype has _is_boolean = True, i.e. only 2 unique non-NA entries,
    then set C=B.
    r   r   r	   r
   data_for_groupingr3   }   s
     r	   TFc                     | j                   S )z#Whether to box the data in a Seriesr   r   s    r
   box_in_seriesr6      s     ==r	   c                      yN   r   xs    r
   <lambda>r<      s    r	   c                      dgt        |       z  S r8   )lenr:   s    r
   r<   r<      s    1#A, r	   c                 2    t        dgt        |       z        S r8   )r   r>   r:   s    r
   r<   r<      s    &!s1v& r	   c                     | S r"   r   r:   s    r
   r<   r<      s    ! r	   )scalarlistseriesobject)r   idsc                     | j                   S )z,
    Functions to test groupby.apply().
    r   r5   s    r
   groupby_apply_oprG      s     ==r	   c                     | j                   S )zU
    Boolean fixture to support Series and Series.to_frame() comparison testing.
    r   r5   s    r
   as_framerI          
 ==r	   c                     | j                   S )zL
    Boolean fixture to support arr and Series(arr) comparison testing.
    r   r5   s    r
   	as_seriesrL      rJ   r	   c                     | j                   S )zd
    Boolean fixture to support comparison testing of ExtensionDtype array
    and numpy array.
    r   r5   s    r
   	use_numpyrN           ==r	   ffillbfillc                     | j                   S )z{
    Parametrized fixture giving method parameters 'ffill' and 'bfill' for
    Series.fillna(method=<method>) testing.
    r   r5   s    r
   fillna_methodrS      rO   r	   c                     | j                   S )zR
    Boolean fixture to support ExtensionDtype _from_sequence method testing.
    r   r5   s    r
   as_arrayrU      rJ   r	   c                 4    t         j                  t               S )z
    A scalar that *cannot* be held by this ExtensionArray.

    The default should work for most subclasses, but is not guaranteed.

    If the array can hold any item (i.e. object dtype), then use pytest.skip.
    )rD   __new__)r   s    r
   invalid_scalarrX      s     >>&!!r	   returnc                  t    t         j                  j                  xr t         j                  j                  dk(  S )z7
    Fixture to check if Copy-on-Write is enabled.
    block)r   modecopy_on_writedata_managerr   r	   r
   using_copy_on_writer_      s(    
 <<%%N',,*C*Cw*NNr	   )r-   r   pandasr   r   fixturer   r   r   r   r   r'   r)   r+   r/   r1   r3   r6   rG   rI   rL   rN   rS   rU   rX   boolr_   r   r	   r
   <module>rc      sf      
      
 /0 1  , 
 
   	 	  
   e}% &
 &	 	/ e}% & e}% & e}% & )* + e}% & " " OT O Or	   