
    `Vg6                   V   d dl mZ d dlmZ d dlZd dlmZmZmZm	Z	m
Z
mZm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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( d dl)m*Z* d dl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: d dl;m<Z<m=Z=m>Z>m?Z? d dl@mAZAmBZBmCZCmDZD d dlEmFZF d dlGmHZHmIZImJZJ d dlKmLc mMZN d dlOmPZPmQZQmRZRmSZSmTZT d dlUmVZV d dlWmXZXmYZYmZZZ d dl[m\Z\ d dl]m^Z^m_Z_m`Z`maZambZbmcZcmdZd d dlemfZf d dlgmhZh d dlimLc mjZk d dllmLc mmc mnZn d dlompZpmqZq d dlrmsZs d dltmLc muZu erd dlvmwZwmxZx d dlymzZz  ej                  d      Z|dCd Z} G d! d"eh      Z~ G d# d$e~      Z G d% d&ej                  e      Z G d' d(ej                  e~      Z G d) d*e      Z G d+ d,ej                  e      ZdDd-Z G d. d/e      Z G d0 d1e      Z G d2 d3e      Z G d4 d5e      ZdEd6ZdFd7ZdGd8ZdHd9ZdId:Z	 	 	 	 	 	 	 	 dJd;ZdKdLd<ZdMdNd=Zd>ddd?d@	 	 	 dOdAZdEdBZy)P    )annotations)wrapsN)TYPE_CHECKINGAnyCallableIterableSequencecastfinal)	Timestamp	internalslibwriters)BlockPlacement)IncompatibleFrequency)	ArrayLikeDtypeObjFIgnoreRaiseShapenptAbstractMethodError)cache_readonly)find_stack_level)validate_bool_kwarg)astype_array_safe)LossySetitemErrorcan_hold_elementfind_result_typemaybe_downcast_to_dtypenp_can_hold_elementsoft_convert_objects)ensure_platform_intis_1d_only_ea_dtypeis_1d_only_ea_objis_dtype_equalis_interval_dtypeis_list_like	is_sparseis_string_dtype)CategoricalDtypeExtensionDtypePandasDtypePeriodDtype)ABCDataFrameABCIndexABCPandasArray	ABCSeries)is_inferred_bool_dtype)is_valid_na_for_dtypeisnana_value_for_dtype)extract_bool_arrayputmask_inplaceputmask_without_repeatsetitem_datetimelike_compatvalidate_putmask)quantile_compat)compare_or_regex_searchreplace_regexshould_use_regex)shift)CategoricalDatetimeArrayExtensionArrayIntervalArrayPandasArrayPeriodArrayTimedeltaArray)SparseDtype)PandasObject)ensure_wrapped_if_datetimelikeextract_array)check_setitem_lengths)Float64IndexIndex)NDArrayBackedExtensionArrayobjectc                L     t               d fd       }t        t        |      S )zp
    If we have a multi-column block, split and operate block-wise.  Otherwise
    use the original method.
    c                    | j                   dk(  s| j                  d   dk(  r | g|i |S  | j                  g|i |S )N   r   )ndimshapesplit_and_operate)selfargskwargsmeths      ]/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/internals/blocks.pynewfunczmaybe_split.<locals>.newfunc   sS     99>TZZ]a/.t.v.. *4))$@@@@    returnlist[Block])r   r
   r   )r[   r]   s   ` r\   maybe_splitrb   {   s,     4[A A 7r^   c                     e Zd ZU dZded<   ded<   ded<   dZd	Zd	Zd	Zd
Z	d
Z
eed               ZeedCd              ZeedCd              ZeedCd              Zed        Zeed               Zed        ZedDd       Zej,                  dEd       ZedFdGd       Ze	 dF	 	 	 dHd       ZedId       ZedJd       ZedKd       Ze	 	 	 	 	 	 dLd       ZedMd       ZedNd       ZedOd       ZdPdQdZ edRd       Z!edOd        Z"edOd!       Z#edGd"       Z$edFdSd#       Z%ee&dOd$              Z'	 	 	 	 dT	 	 	 	 	 	 	 	 	 dUd%Z(edVd&       Z)e	 dW	 	 	 	 	 	 	 dXd'       Z*edYdGd(       Z+edZd[d)       Z,e	 	 d\	 	 	 	 	 d]d*       Z-e	 	 	 d^	 	 	 	 	 d_d+       Z.e	 	 d`	 	 	 	 	 	 	 	 	 dad,       Z/e	 	 db	 	 	 	 	 	 	 dcd-       Z0ddd.Z1d/ Z2eded0       Z3dfd1Z4	 	 	 	 dgd2Z5dPdhd3Z6de7jp                  f	 	 	 	 	 	 	 did4Z9	 	 	 	 djd5Z:dGd6Z;dOd7Z<dkdOd8Z=	 dl	 	 	 	 	 dmd9Z>	 	 	 	 	 	 	 	 	 dn	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dod:Z?dpdqd;Z@drdsd<ZAe	 dt	 	 	 	 	 dud=       ZBdGd>ZCedCd?       ZDedvd@       ZEdFdwdAZFdxdBZGy)yBlockz
    Canonical n-dimensional unit of homogeneous dtype contained in a pandas
    data structure

    Index-ignorant; let the container take care of that
    np.ndarray | ExtensionArrayvaluesintrU   r   __init__ FTc                F    | j                   | j                  j                  fS N)_can_consolidatedtypenamerX   s    r\   _consolidate_keyzBlock._consolidate_key   s     $$djjoo55r^   c                    | j                   }t        |t        j                         r|j                  dvS |j                  S )z7
        Can we store NA values in this Block?
        )biu)rm   
isinstancenpkind_can_hold_narX   rm   s     r\   rx   zBlock._can_hold_na   s6     

eRXX&::_44!!!r^   c                ~    t        j                  dt        t                      t	        | j
                  t              S )NzBlock.is_categorical is deprecated and will be removed in a future version.  Use isinstance(block.values, Categorical) instead. See https://github.com/pandas-dev/pandas/issues/40226
stacklevel)warningswarnDeprecationWarningr   ru   rf   rB   ro   s    r\   is_categoricalzBlock.is_categorical   s4     	M ')	
 $++{33r^   c                ,    t        | j                        S )z^
        We can be bool if a) we are bool dtype or b) object dtype with bool objects.
        )r4   rf   ro   s    r\   is_boolzBlock.is_bool   s     &dkk22r^   c                ,    t        | j                        S rk   )external_valuesrf   ro   s    r\   r   zBlock.external_values   s    t{{++r^   c                0    t        | j                  d      S )NF)compat)r7   rm   ro   s    r\   
fill_valuezBlock.fill_value   s     "$**U;;r^   c                p    | j                   t        k7  r"t        || j                         r| j                  }|S rk   )rm   
_dtype_objr5   r   rX   values     r\   _standardize_fill_valuezBlock._standardize_fill_value   s,     ::#(=eTZZ(POOEr^   c                    | j                   S rk   	_mgr_locsro   s    r\   mgr_locszBlock.mgr_locs   s    ~~r^   c                    || _         y rk   r   )rX   new_mgr_locss     r\   r   zBlock.mgr_locs   s	    %r^   Nc                    || j                   }| j                  rt        || j                        }t	        ||| j                        S )zm
        Create a new block, with type inference propagate any values that are
        not specified
        rU   	placementrU   )r   is_extensionensure_block_shaperU   	new_block)rX   rf   r   s      r\   
make_blockzBlock.make_block   sA     I'TYY?F 9499EEr^   c                    || j                   }|j                  j                  dv r5t        |      }||ur$t	        j
                  dt        t                      |} t        |       ||| j                        S )z2Wrap given values in a block of same type as self.)mMzIn a future version, Block.make_block_same_class will assume that datetime64 and timedelta64 ndarrays have already been cast to DatetimeArray and TimedeltaArray, respectively.r{   r   )
r   rm   rw   rK   r}   r~   r   r   typerU   )rX   rf   r   
new_valuess       r\   make_block_same_classzBlock.make_block_same_class   su    
 I<<
*7?J'$ '/1  F tDz&IDIIFFr^   c                P   t        |       j                  }| j                  dk(  r| dt        |        d| j                   }|S dj                  | j                  D cg c]  }t        |       c}      }| d| j                  j                   d| d| j                   }|S c c}w )NrT   z: z dtype: z x z, z	, dtype: )
r   __name__rU   lenrm   joinrV   strr   indexer)rX   rn   resultsrV   s        r\   __repr__zBlock.__repr__  s     Dz""99>vRD	{(4::,?F  JJ

;1A;<EvR 5 56byUF  <s   B#c                ,    t        | j                        S rk   )r   rf   ro   s    r\   __len__zBlock.__len__  s    4;;r^   c                    | j                   |   }| j                  |      }|j                  | j                  j                  k7  rt	        d       t        |       ||| j                        S z
        Perform __getitem__-like, return result as block.

        Only supports slices that preserve dimensionality.
        z Only same dim slicing is allowed)r   _slicerU   rf   
ValueErrorr   rX   slicerr   r   s       r\   getitem_blockzBlock.getitem_block  s[     ~~f-[[(
??dkk...?@@tDz*lDII>>r^   c                    | j                  |      }|j                  | j                  j                  k7  rt        d       t	        |       ||| j                        S r   )r   rU   rf   r   r   r   s       r\   getitem_block_columnszBlock.getitem_block_columns-  sM     [[(
??dkk...?@@tDz*lDII>>r^   c                H    t        |d      }t        | j                  |      S )z#require the same dtype as ourselvesTextract_numpy)rL   r   rf   )rX   elements     r\   _can_hold_elementzBlock._can_hold_element=  s!      t<W55r^   c                T    	 |j                   | j                   k(  S # t        $ r Y yw xY w)z
        Should we set self.values[indexer] = value inplace or do we need to cast?

        Parameters
        ----------
        value : np.ndarray or ExtensionArray

        Returns
        -------
        bool
        F)rm   	TypeErrorr   s     r\   should_storezBlock.should_storeC  s,    	;;$**,, 		s    	''c                J     || j                   fi |}| j                  |      S )z[
        apply the function to my values; return a block if we are not
        one
        )rf   _split_op_result)rX   funcrZ   r   s       r\   applyzBlock.applyY  s(     dkk,V,$$V,,r^   c                ,   | j                   dk(  sJ 	  || j                        }| j                  j                   dk(  rt	        j
                  |gg      }n|j                  dd      }| j                  |      }|gS # t        t        f$ r |rg cY S  w xY w)N   rT   )rU   rf   r   NotImplementedErrorrv   arrayreshaper   )rX   r   ignore_failuresr   
res_valuesnbs         r\   reducezBlock.reducec  s     yyA~~	$++&F ;;q F8*-JA.J__Z(t ./ 			s   A< <BBc                8   |j                   dkD  rxt        |j                  t              r^g }t	        | j
                        D ]B  \  }}t        |      s	|||dz    }n||   }| j                  ||      }|j                  |       D |S | j                  |      }|gS )NrT   )rf   r   )	rU   ru   rm   r-   	enumerater   r&   r   append)rX   r   nbsrs   locvalsblockr   s           r\   r   zBlock._split_op_resultx  s     ;;?z&,,G C#DNN3 "3(0!!a!e,D!!9DtsC

5!" J__V$tr^   c                    | j                   dk(  sJ g }t        | j                        D ]Q  \  }}| j                  t	        ||dz            }t        |      } t        |       ||d      }|j                  |       S |S )zD
        Split a block into a list of single-column blocks.
        r   rT   r   )rU   r   r   rf   slicer   r   r   )rX   
new_blocksrs   ref_locr   bpr   s          r\   _splitzBlock._split  s    
 yyA~~
#DNN3 	"JAw;;uQA/D(BdDBQ7Bb!	" r^   c                    | j                   dk(  r| j                  d   dk7  sJ g }| j                         D ]  } ||g|i |}|j                  |       ! |S )z
        Split the block and apply func column-by-column.

        Parameters
        ----------
        func : Block method
        *args
        **kwargs

        Returns
        -------
        List[Block]
        r   r   rT   )rU   rV   r   extend)rX   r   rY   rZ   
res_blocksr   rbss          r\   rW   zBlock.split_and_operate  sh     yyA~$**Q-1"444
++- 	#Br+D+F+Cc"	# r^   c                T    t        | j                  |      }| j                  |d      S )z
        coerce the current block to a dtype compat for other
        we will return a block, possibly object, and not raise

        we can also safely try to coerce to the same dtype
        and will receive the same block
        Fcopy)r    rf   astype)rX   other	new_dtypes      r\   coerce_to_target_dtypezBlock.coerce_to_target_dtype  s'     %T[[%8	{{95{11r^   c           	         |du r|S | j                   t        k(  r*t        |D cg c]  }|j                  dd       c}      S ||S t        |D cg c]  }|j	                  |       c}      S c c}w c c}w )NFT)datetimenumeric)rm   r   extend_blocksconvert_downcast_2d)rX   blocksdowncastblkrr   s        r\   _maybe_downcastzBlock._maybe_downcast  s}    uM::# !FLMsdE:M  MG1annX6GHH N Hs   A0A5c                T    t        | j                  |      }| j                  |      gS )zs
        downcast specialized to 2D case post-validation.

        Refactored to allow use of maybe_split.
        rm   )r!   rf   r   )rX   rm   r   s      r\   r   zBlock._downcast_2d  s&     -T[[F

+,,r^   c                .    |r| j                         gS | gS )z
        attempt to coerce any object types to better types return a copy
        of the block (if copy = True) by definition we are not an ObjectBlock
        here!
        r   )rX   r   r   r   	timedeltas        r\   r   zBlock.convert  s     !%		}04&0r^   c                .    | j                   j                  S rk   rf   rm   ro   s    r\   rm   zBlock.dtype      {{   r^   c                T   | j                   }t        ||||      }t        |      }| j                  |      }|j                  | j                  k7  rWt        d| d| j                  j                   d| j                   d|j                  j                   d|j                   d      |S )a  
        Coerce to the new dtype.

        Parameters
        ----------
        dtype : np.dtype or ExtensionDtype
        copy : bool, default False
            copy if indicated
        errors : str, {'raise', 'ignore'}, default 'raise'
            - ``raise`` : allow exceptions to be raised
            - ``ignore`` : suppress exceptions. On error return original object

        Returns
        -------
        Block
        )r   errorszcannot set astype for copy = [z] for dtype (z [z]) to different shape (z]))rf   r   maybe_coerce_valuesr   rV   r   rm   rn   )rX   rm   r   r   rf   r   newbs          r\   r   zBlock.astype  s    ( &vu4O
(4
z*::#0 7JJOO$Btzzl 3JJOO$Btzzl"6 
 r^   c                V    t        | j                  f||d|}| j                  |      S )"convert to our native types format)na_repquoting)to_native_typesrf   r   )rX   r   r   rZ   r   s        r\   r   zBlock.to_native_types  s.     !WVWWPVWv&&r^   c                    | j                   }|r|j                         } t        |       || j                  | j                        S )zcopy constructorr   )rf   r   r   r   rU   )rX   deeprf   s      r\   r   z
Block.copy   s8     [[]FtDz&DNNKKr^   c                   | j                   }t        |t              r5|r| n| j                         }|j                   j	                  ||d       |gS | j                  |      s|r| gS | j                         gS |t        j                  ||      }|j                         s|r| gS | j                         gS | j                  |      rS|r| n| j                         }t        |j                   ||       | j                  r||j                  dd      }|S |g}|S | j                  dk(  s| j                  d   dk(  rQ|)| j                  t        j                   t"                    }n| j%                  |      }|j'                  ||d|      S g }t)        | j+                               D ]9  \  }}	|j-                  t/        |       j'                  |	||d|||dz                 ; |S )z
        replace the to_replace value with value, possible to create new
        blocks here this is just a call to putmask.
        T)
to_replacer   inplaceFr   r   rT   r   r   r   r  mask)rf   ru   rB   r   _replacer   missingmask_missinganyr9   	is_objectr   rU   rV   r   rv   rm   rQ   r   replacer   r   r   r   )
rX   r   r   r  r  rf   r   r   rs   r   s
             r\   r
  zBlock.replace+  s   " fk*!$tyy{C JJ%UD    5L%%j1
 %D67499;-7<''
;Dxxz %D67499;-7##E*!$tyy{CCJJe4NNu} U? M MYY!^tzz!}1}kk"((6"2311%8;;%	    F"4;;=1 	2J&&#-# $!!a!e_ ' 	 Mr^   c                .   | j                  |      s|r| gS | j                         gS t        j                  |      }|r| j                  n| j                  j                         }t        ||||       | j                  |      }|j                  dd      S )aP  
        Replace elements by the given value.

        Parameters
        ----------
        to_replace : object or pattern
            Scalar to replace or regular expression to match.
        value : object
            Replacement object.
        inplace : bool, default False
            Perform inplace modification.
        convert : bool, default True
            If true, try to coerce any object types to better types.
        mask : array-like of bool, optional
            True indicate corresponding element is ignored.

        Returns
        -------
        List[Block]
        Fr  )r   r   recompilerf   r?   r   r   )	rX   r   r   r  r   r  rxr   r   s	            r\   _replace_regexzBlock._replace_regex|  s    : %%j1 %D67499;-7ZZ
#$+T[[1A1A1C
j"eT2
+}}U}77r^   c                   | j                   }t        ||      D cg c]  \  }}| j                  |      s||f }}}t        |      s|r| gS | j	                         gS t        |      dz
  }	t        |j                        r,t        |       }
|D cg c]  }t        ||d   ||
       }}n&|D cg c]  }t        j                  ||d          }}|D cg c]  }t        |       }}|r| n| j	                         g}t        |      D ]  \  }\  }}||	k(  }g }t        |      D ]  \  }}t        |      dk(  r||   }n||   }t        |t              rJ |||dz    }|j                  |||||      }|rH|j                   r<t#        d |D              s*t%        |D cg c]  }|j'                  dd       c}      }|j)                  |        |} |S c c}}w c c}w c c}w c c}w c c}w )	z:
        See BlockManager.replace_list docstring.
        rT   r   )regexr  )r   r   r  r  r  c              3  $   K   | ]  }|d u  
 y wrk   ri   .0xs     r\   	<genexpr>z%Block.replace_list.<locals>.<genexpr>  s     8Vqd8Vs   FTr  )rf   zipr   r   r   r+   rm   r6   r>   r  r  r8   r   ru   bool_replace_coercer	  allr   r   r   )rX   src_list	dest_listr  r  rf   r  ypairssrc_lenr  r   masksrbrs   srcdestr   new_rbblk_numr   r   mibr   rr   s                            r\   replace_listzBlock.replace_list  s+      #8Y7
q!4;Q;QRS;TQF
 
 5z$D67499;-7e*q.6<<( L=D  (!EME  BGGAW))&!A$7GEG
 1661#A&66d499;/'. 	NA{T7lG"$F
 !*" &r7a<aA(C)#t444Ggk2A
 ,,"# -  s}}S8VI8V5V*FLM5t<MF f%/&0 B?	@ 	w
 H
 7> Ns"   GGG 3 G%G* G/c                t   t        ||      r| j                  |||d|      S ||j                         rZ| j                  t	        j
                  t              d      }|| u r|s|j                         }t        |j                  ||       |gS |r| gS | j                         gS | j                  ||||      S )ai  
        Replace value corresponding to the given boolean array with another
        value.

        Parameters
        ----------
        to_replace : object or pattern
            Scalar to replace or regular expression to match.
        value : object
            Replacement object.
        mask : np.ndarray[bool]
            True indicate corresponding element is ignored.
        inplace : bool, default True
            Perform inplace modification.
        regex : bool, default False
            If true, perform regular expression substitution.

        Returns
        -------
        List[Block]
        F)r  r   r  r   r  )r@   r  r  r   rv   rm   rQ   r   r9   rf   r
  )rX   r   r   r  r  r  r   s          r\   r  zBlock._replace_coerce  s    < E:.&& '   }88:RXXf%5EBBTz'WWY#BIItU;4K!(v;tyy{m;<<%UG$    r^   c                    |S zA
        For compatibility with 1D-only ExtensionArrays.
        ri   rX   args     r\   _maybe_squeeze_argzBlock._maybe_squeeze_arg)  s	     
r^   c                    |S r*  ri   )rX   r   s     r\   _unwrap_setitem_indexerzBlock._unwrap_setitem_indexer/  s	     r^   c                .    | j                   j                  S rk   )rf   rV   ro   s    r\   rV   zBlock.shape7  r   r^   c                     | j                   |   S rk   rf   )rX   rs   s     r\   igetz
Block.iget;  s     {{1~r^   c                     | j                   |   S )zreturn a slice of my valuesr2  )rX   r   s     r\   r   zBlock._sliceD  s    
 {{6""r^   c                d    |r| j                   j                         | _         || j                   |<   y)a  
        Modify block values in-place with new item value.

        If copy=True, first copy the underlying values in place before modifying
        (for Copy-on-Write).

        Notes
        -----
        `set_inplace` never creates a new array or new Block, whereas `setitem`
        _may_ create a new array and always creates a new Block.

        Caller is responsible for checking values.dtype == self.dtype.
        Nrf   r   rX   locsrf   r   s       r\   set_inplacezBlock.set_inplaceK  s)     ++**,DK"Dr^   c                J   | j                   }|t        j                  u r| j                  }d}nd}t	        j
                  |||||      }|dk(  r|J || j                  }t        |j                  | j                        s| j                  ||      S | j                  ||      S )N
        Take values according to indexer and return them as a block.
        FT)axis
allow_fillr   r   )rf   r   
no_defaultr   algostake_ndr   r'   rm   r   r   )rX   r   r<  r   r   rf   r=  r   s           r\   r@  zBlock.take_nd]  s     'JJJ ]]G$:*

 AI,"677>>Lj..

;??:|<<--j,GGr^   c                    |j                  | j                  j                  |      \  }}|j                  d      }|j                  |   }||   }t	        |      }t        ||      g}||fS )a  
        Return a list of unstacked blocks of self

        Parameters
        ----------
        unstacker : reshape._Unstacker
        fill_value : int
            Only used in ExtensionBlock._unstack
        new_placement : np.ndarray[np.intp]
        allow_fill : bool
        needs_masking : np.ndarray[bool]

        Returns
        -------
        blocks : list of Block
            New blocks of unstacked values.
        mask : array-like of bool
            The mask of columns of `blocks` we should keep.
        r   r   r   )get_new_valuesrf   Tr  r   new_block_2d)	rX   	unstackerr   new_placementneeds_maskingr   r  r   r   s	            r\   _unstackzBlock._unstack  sw    4 %33KKMMj 4 

D xx{  \\$'
%d+M*zR89t|r^   c                   | j                  |      }t        t        j                  | j                        }| j
                  dk(  r|j                  }t        |||       t        |d      }	 t        |j                  |      }| j                  t        k(  r0||   }t        j                  |      rt        |t        |      |      }|||<   | S # t         $ r& | j#                  |      }|j%                  ||      cY S w xY w)a  
        Attempt self.values[indexer] = value, possibly creating a new array.

        Parameters
        ----------
        indexer : tuple, list-like, array-like, slice, int
            The subset of self.values to set
        value : object
            The value being set

        Returns
        -------
        Block

        Notes
        -----
        `indexer` is a direct slice/positional indexer. `value` must
        be a compatible shape.
        r   Tr   )r   r
   rv   ndarrayrf   rU   rE  rM   rL   r"   rm   r   r   r)   r;   r   r   r   setitem)rX   r   r   rf   castedvir   s          r\   rM  zBlock.setitem  s    * ,,U3bjj$++.99>XXF 	guf5e48	%(u=F zzZ'G_##B' 9R&QF$F7O ! 	.,,U3B::gu--	.s   ,C ,C;:C;c                   |}t        t        j                  | j                        }t	        |j
                  |      \  }}t        |t        t        t        f      rJ |t        j                  u r| j                  }| j                  |      }t        |d      }|r| gS 	 t        |j                   |      }t#        |j
                  ||       | gS # t$        $ r | j&                  dk(  s| j(                  d   dk(  r[t+        |      s#| j-                  |      j/                  ||      cY S |j1                         d   }| j3                  |||         }|gcY S t        |t        j                        }	g }
| j5                         }t7        |      D ]H  \  }}|}|	r|dd||dz   f   }|dd||dz   f   }|j/                  ||      }|
j9                  |       J |
cY S w xY w)aV  
        putmask the data to the block; it is possible that we may create a
        new dtype of block

        Return the resulting block(s).

        Parameters
        ----------
        mask : np.ndarray[bool], SparseArray[bool], or BooleanArray
        new : a ndarray/object

        Returns
        -------
        List[Block]
        Tr   rT   r   N)r
   rv   rL  rf   r<   rE  ru   r1   r3   r0   r   r>  r   r   rL   r"   rm   r:   r   rU   rV   r)   r   putmasknonzerorM  r   r   r   )rX   r  new	orig_maskrf   nooprN  r   r   is_arrayr   r   rs   nsubmaskr   s                   r\   rQ  zBlock.putmask  s     	bjj$++.%fhh5
dcHi#FGGG#.. //C**3/Ct46M	"(s;F"688T6:6M  	"yyA~A!!3 $C(66s;CCD#NN"llnQ/Ggs7|<B4K &c2::6
kkm&s^ +EArA1q1u9-'1q1u95G**Wa0C%%c*+ "!7	"s    /C AG(+GBGGc                H   |j                   | j                   k(  sJ t        |t        t        t        f      rJ | j                   dk(  }t        |      }t        t        j                  | j                        }|}|r|j                  }t        ||       \  }}|r| j                         gS |t        j                  u r| j                  }| j!                  |      }	 t#        |j$                  |      }	|	}t'        ||j)                         |      }
|
|urmt+        |      r:t-        |      t-        |      k  r#t        j.                  | ||       t1        d      |j                         }t        j2                  |||
       nt+        |      rct        |t        j                        sIt-        |      | j4                  d   k(  r.t        j6                  |      j9                  |j4                        }t;        j.                  | ||      }	 |r|j                  }| jO                  |      gS # t<        t>        t@        f$ r | j                   dk(  s| j4                  d   dk(  r8| jC                  |      }|j/                  ||      }| jE                  ||      cY S t        |t        j                  tF        f      }g }| jI                         }tK        |      D ]J  \  }}|}|r|dd||dz   f   }|dd||dz   f   }|j/                  |||      }|jM                  |       L |cY S w xY w)	a  
        evaluate the block; return result block(s) from the result

        Parameters
        ----------
        other : a ndarray/object
        cond : np.ndarray[bool], SparseArray[bool], or BooleanArray
        _downcast : str or None, default "infer"
            Private because we only specify it when calling from fillna.

        Returns
        -------
        List[Block]
        r   zThis should not be reached; call to np.where above is expected to raise ValueError. Please report a bug at github.com/pandas-dev/pandasr   rT   r   r   N	_downcast)(rU   ru   r1   r3   r0   r8   r
   rv   rL  rf   rE  r<   r   r   r>  r   r   r"   rm   r;   sumr)   r   wherer   rQ  rV   r   r   expressionsr   r   r   r   r   rD   r   r   r   r   )rX   r   condr\  	transposerf   
orig_othericondrU  rN  altr   r   r   rV  r   r   rs   r   othrX  r   s                         r\   r^  zBlock.where  s    yyDII%%%eh	<%HIIIIIN	!$' bjj$++.
XXF&vu5tIIK= CNN"OOE,,U3@	B )u=F> E-feiik5IC%&3u:F+CHHeVVU3-7 
  

65#.
 !'&ubjj9E
djjn4
 HHUO33FLLAE
 %**E665A XXF'((E I'89 	" yyA~A!!3 33E:Z6++FY+GG &ebjj.-IJ
kkm&s^ +EArC#Aq1q5yL1"1a!a%i<0G((39(EC%%c*+ "!7	"s   H% %A+L!BL! L!c           	        t        |d      }| j                  sd}n.t        | j                        }t	        | j                  |      \  }}|r+|r| gS | j                         }|j                  |g|      }|S |$d|j                  | j                  dz
        |kD  <   |r| j                  j                  |      }n| j                  |j                   d      }t        |D 	cg c]  }	|	j                  |	g|       c}	      S c c}	w )zs
        fillna on the block with the value. If we fail, then convert to
        ObjectBlock and try again
        r  TrZ  FrT   r[  )r   rx   r6   rf   r<   r   r   cumsumrU   rQ  rE  r^  r   )
rX   r   limitr  r   rU  r  r   r   r   s
             r\   fillnazBlock.fillna  s    &gy9  D$D)$++t<JD$ v YY[(("(A
7<DTYY]+e34,,tvvu-C **UTVVGu*=C
 FIJsS  # :J
 	
Js   $Dc
                   t        |d      }| j                  s|r| gS | j                         gS 	 t        j                  |      }|/| j                  j                  dk7  r|r| gS | j                         gS | j                  rU| j                  dk(  rF| j                  d   dk7  r4|dk(  r/ | j                  t        |       j                  |||||||||	f
i |
S |r| j                  n| j                  j                         }t        t         j"                  |      }t        j$                  |f|||||||d|
 | j'                  |      }|j)                  |g|	      S # t
        $ r d }Y $w xY w)Nr  fr   r   rT   )methodr<  indexrh  limit_direction
limit_arear   )r   rx   r   r  clean_fill_methodr   rm   rw   r	  rU   rV   rW   r   interpolaterf   r
   rv   rL  interpolate_array_2dr   r   )rX   rl  r<  rm  r  rh  rn  ro  r   r   rZ   r   datar   s                 r\   rq  zBlock.interpolate  s    &gy9  $D67499;-7	))&1A 9C/ %D67499;-7>>dii1nA!1CPQ	)4))T
&&   &t{{4;;+;+;+=BJJ%$$
	
+!!
	
 
	
 ''-!!2$11Q  	A	s   E E*)E*c                l    t        j                  | j                  ||      }| j                  |      gS )z'return block for the diff of the valuesr<  r2  )r?  diffrf   r   )rX   rW  r<  r   s       r\   rv  z
Block.diff  s,    ZZQT:
z233r^   c                   t        j                  |      s| j                  t        k7  rt	        d      | j                  |      }	 t        | j                  |      }t        t        j                  | j                        }t        ||||      }| j                  |      gS # t        $ r( | j                  |      }|j                  |||      cY S w xY w)z+shift the block by periods, possibly upcastzfill_value must be a scalar)r<  r   )r   	is_scalarrm   r   r   r   r"   r
   rv   rL  rf   rA   r   r   r   )rX   periodsr<  r   rN  rf   r   r   s           r\   rA   zBlock.shift  s     }}Z(TZZ:-E :;;11*=
	1 )

JF "**dkk2Fvwf=JOOJ/00 ! 	G,,Z8B88G$:8FF	Gs   B   .CCc                    | j                   dk(  sJ |dk(  sJ t        |      sJ t        | j                  t	        j
                  |j                        |      }t        |d      }t        || j                        S )a\  
        compute the quantiles of the

        Parameters
        ----------
        qs : Float64Index
            List of the quantiles to be computed.
        interpolation : str, default 'linear'
            Type of interpolation.
        axis : int, default 0
            Axis to compute.

        Returns
        -------
        Block
        r   rT   r   rC  )
rU   r)   r=   rf   rv   asarray_valuesr   rF  r   )rX   qsinterpolationr<  r   s        r\   quantilezBlock.quantile  sl    * yyA~~qyyB bjj.DmT $F3Fdnn==r^   c                    t        |       )zC
        Return a new Block with the given loc(s) deleted.
        r   )rX   r   s     r\   deletezBlock.delete@  s     "$''r^   c                    t        |       )(return a boolean if I am possibly a viewr   ro   s    r\   is_viewzBlock.is_viewF  s     "$''r^   c                    t        |       )zP
        The array that Series.array returns. Always an ExtensionArray.
        r   ro   s    r\   array_valueszBlock.array_valuesK      
 "$''r^   c                    t        |       )z
        return an internal format, currently just the ndarray
        this is often overridden to handle to_dense like operations
        r   ry   s     r\   
get_valueszBlock.get_valuesR  r  r^   c                    t        |       rk   r   ro   s    r\   values_for_jsonzBlock.values_for_jsonY  s    !$''r^   r`   r  )r`   r   )r   r   r`   Nonerk   r`   rd   )r   BlockPlacement | Noner`   rd   )r`   r   )r`   rg   )r   zslice | npt.NDArray[np.intp]r`   rd   )r   r   r   r   r`   rd   )r   r   r`   r  )r   r   r`   r  r_   Fr   r  r`   ra   )r   r   r`   ra   )r   ra   r`   ra   TTTT
r   r  r   r  r   r  r   r  r`   ra   r`   r   )Fraise)rm   r   r   r  r   r   r`   rd   )nanN)T)r   r  r`   rd   )FN)r  r  r  znpt.NDArray[np.bool_] | Noner`   ra   )FTN)r  r  r   r  r`   ra   )FF)
r  zIterable[Any]r  zSequence[Any]r  r  r  r  r`   ra   )TF)r  npt.NDArray[np.bool_]r  r  r  r  r`   ra   )r,  
np.ndarrayr`   r  r`   r   )rs   )int | tuple[int, int] | tuple[slice, int]r`   r  )r   4slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]r`   r   rf   r   r   r  r`   r  r   npt.NDArray[np.intp]r<  rg   r   r  r`   rd   rH  r  rI  r  inferNFNrh  
int | Noner  r  r`   ra   )	padr   NFNforwardNNN)rl  r   r<  rg   rm  zIndex | Noner  r  rh  r  rn  r   ro  
str | Noner   z
Any | Noner   r  r`   ra   rT   rW  rg   r<  rg   r`   ra   r   Nry  rg   r<  rg   r   r   r`   ra   )linearr   )r}  rN   r<  rg   r`   rd   r`   rD   rm   DtypeObj | Noner`   r  r`   r  )Hr   
__module____qualname____doc____annotations__	__slots__
is_numericr	  r   rl   _validate_ndimr   r   rp   rx   r   propertyr   r   r   r   r   setterr   r   r   r   r   r   r   r   r   r   r   r   rW   r   r   rb   r   r   rm   r   r   r   r
  r  r'  r  r-  r/  rV   r3  r   r9  r   r>  r@  rJ  rM  rQ  r^  ri  rq  rv  rA   r  r  r  r  r  r  ri   r^   r\   rd   rd      s    ('
IIJILN
6  6 "  " 4  4 3  3 , , <  <     __& & F F 9=G!6G	G G2 
 
     ? ?* ??+9?	? ? 6 6
  * - -*  (    2 
2 
2 I I& -  - 11 1 	1
 1 
1" ! ! IP%);F	 B ' '
 L L 
 -1N 	N +N 
N N` 
 '8 	'8
 '8 
'8 '8R 
 HH !H 	H
 H 
H HT  1 $	1
 1 1 
1 1n ! !#J#	##, /3>> H% H  H ,	 H 
 HD* ,	*
 -*\.`="~m)` PT,
&,
8<,
	,
` " (!%!%#>2>2 >2 	>2
 >2 >2 >2 >2 >2 >2 
>2@4
1@ DE>>>A>	> >B( ( ( ( (((r^   rd   c                       e Zd ZU dZded<   d ZdddZddZ	 d	 	 	 	 	 d fdZddZ	e
dd	       Zddd
ZddZ	 ddZ xZS )EABackedBlockz>
    Mixin for Block subclasses backed by ExtensionArray.
    rD   rf   c                   |}|}| j                  |      }| j                  |      }| j                  }|j                  dk(  r|j                  }t        |||       	 |||<   | S # t        t        f$ r}t        |       t        | j                        r(| j                  |      }|j                  ||      cY d}~S t        | t              r(| j                  |      }|j                  ||      cY d}~S  d}~ww xY w)a7  
        Attempt self.values[indexer] = value, possibly creating a new array.

        This differs from Block.setitem by not allowing setitem to change
        the dtype of the Block.

        Parameters
        ----------
        indexer : tuple, list-like, array-like, slice, int
            The subset of self.values to set
        value : object
            The value being set

        Returns
        -------
        Block

        Notes
        -----
        `indexer` is a direct slice/positional indexer. `value` must
        be a compatible shape.
        r   N)r/  r-  rf   rU   rE  rM   r   r   _catch_deprecated_value_errorr(   rm   r   rM  ru   NDArrayBackedExtensionBlock)rX   r   r   orig_indexer
orig_valuerf   errr   s           r\   rM  zEABackedBlock.setitemd  s    . 
..w7''.;;! XXFguf5	#F7O" K! I& 	)#. ,00<zz,
;;D"=>00<zz,
;; 	s1   A# #C82AC34C8:2C3,C82C33C8c                R   | j                   j                  }t        |      }|}|}| j                  |      }| j                  |      }|t        j
                  u r| j                  }t        ||       \  }}|r| j                         gS 	 |j                  ||      j                  }	| j9                  |	      }|gS # t        t        f$ r\}
t        |
       | j                  dk(  s| j                  d   dk(  rt        | j                         r;| j#                  |      }|j%                  ||      }| j'                  ||      cY d }
~
S t)        | t*              r;| j#                  |      }|j%                  ||      }| j'                  ||      cY d }
~
S  t)        |t,        j.                  t0        f      }g }| j3                         }t5        |      D ]H  \  }}|}|r|d d ||dz   f   }|d d ||dz   f   }|j%                  ||      }|j7                  |       J |cY d }
~
S d }
~
ww xY w)NrT   r   rZ  )rf   rE  r8   r-  r   r>  r   r<   r   _wherer   r   r  rU   rV   r(   rm   r   r^  r   ru   r  rv   rL  rD   r   r   r   r   )rX   r   r`  r\  arrrb  	orig_condrc  rU  r   r  r   r   rV  r   rs   r   rW  rX  r   s                       r\   r^  zEABackedBlock.where  s   kkmm!$'
	''.&&t,CNN"OOE&sTE2t IIK= &	"D%022JN ''
3tO I& $	")#.yyA~A!!3$TZZ055jAC))J	:C//i/HH&AB 55jAC))J	:C//i/HH  &j2::~2NO
kkm&s^ +EAr"A&q!a!e)|4'1q1u95G((1g.C%%c*+ "!I$	"s9   
B: :H&
A6H! H&AH!H&B
H!H&!H&c                   t        |      }| j                  }|j                  dk(  r|j                  }|}|}| j	                  |      }| j	                  |      }|j                         s| gS 	 |j                  ||       | gS # t        t        f$ r6}t        |       | j                  dk(  s| j                  d   dk(  rvt        | j                        r(| j                  |      }|j                  ||      cY d}~S t        | t               r(| j                  |      }|j                  ||      cY d}~S  t        |t"        j$                  t&        f      }g }	| j)                         }
t+        |
      D ]H  \  }}|}|r|dd||dz   f   }|dd||dz   f   }|j                  ||      }|	j-                  |       J |	cY d}~S d}~ww xY w)z+
        See Block.putmask.__doc__
        r   rT   r   N)r8   rf   rU   rE  r-  r  _putmaskr   r   r  rV   r(   rm   r   rQ  ru   r  rv   rL  rD   r   r   r   )rX   r  rS  rf   orig_newrT  r  r   rV  r   r   rs   r   rW  rX  r   s                   r\   rQ  zEABackedBlock.putmask  s    "$';;!XXF	%%c*&&t,xxz6M&	"OOD#&L vK :& #	")#.yyA~A!!3$TZZ0 55h?C;;y(;;&AB 55h?C;;y(;;  &h^0LM
kkm&s^ +EAr A$QAE	\2'1q1u95G**Wa0C%%c*+ "!G#	"s8   -B GA#G5G;2G-G3B
G=GGc                J   | j                   j                  dk(  r2	 | j                  j                  ||      }| j	                  |      }|gS t        |   ||||      S # t
        t        f$ r3 t        j                  dt        |       dt        t                       w xY w)Nr   )rh  zMThe behavior of fillna with timedelta64[ns] dtype and an incompatible value (z) is deprecated. In a future version, this will cast to a common dtype (usually object) instead of raising, matching the behavior of other dtypes.r{   )rh  r  r   )rm   rw   rf   ri  r   r   r   r}   r~   r   FutureWarningr   super)rX   r   rh  r  r   r   res_blk	__class__s          r\   ri  zEABackedBlock.fillna  s    
 ::??c!!![[//U/C
 //*5y 
 w~e5'H~UU' 	* ..25k] ;00
 "/1 s   A   AB"c                    | j                   j                  |      }| j                  j                  |      } t        |       ||| j                        S )Nr   )rf   r  r   r   rU   rX   r   rf   r   s       r\   r  zEABackedBlock.delete4  sC    ##C(>>((-tDz&H499EEr^   c                    | j                   S rk   r2  ro   s    r\   r  zEABackedBlock.array_values:  s    {{r^   c                    | j                   }|t        k(  r|j                  t              }t	        j
                  |      j                  | j                        S )zS
        return object dtype as boxed values, such as Timestamps/Timedelta
        )rf   r   r   rQ   rv   r{  r   rV   )rX   rm   rf   s      r\   r  zEABackedBlock.get_values>  sA     !KKJ]]6*Fzz&!))$**55r^   c                @    t        j                  | j                        S rk   )rv   r{  rf   ro   s    r\   r  zEABackedBlock.values_for_jsonH  s    zz$++&&r^   c                    | j                   }|j                  dk(  r.|dk(  r)|j                  j                  |||      j                  }n|j                  |||      }| j	                  |      S )Nr   r   )r   rl  rh  )rf   rU   rE  ri  r   )	rX   rl  r<  r  rh  r   rZ   rf   r   s	            r\   rq  zEABackedBlock.interpolateK  sc     ;;!	z&PUVXXJZeTJ))*55r^   r  r_   r  r  r  r  rk   r  r  )r  r   FNN)r   r  r  r  r  rM  r^  rQ  ri  r  r   r  r  r  rq  __classcell__r  s   @r\   r  r  ]  sz     6p=~:z PTV&V8<V	V:F  6' KO	6r^   r  c                       e Zd ZU dZdZdZdZded<   edd       Z	ddZ
dddZd	 Zd
 Zedd       Zed        Zddej$                  f	 	 	 	 	 	 	 ddZ	 	 	 	 ddZedd       Zdd fdZdd dZ	 	 	 	 d!dZ xZS )"ExtensionBlocka  
    Block for holding extension types.

    Notes
    -----
    This holds all 3rd-party extension array types. It's also the immediate
    parent class for our internal extension types' blocks, CategoricalBlock.

    ExtensionArrays are limited to 1-D.
    FTrD   rf   c                    | j                   dk(  rt        | j                        fS t        | j                        t        | j                        fS )NrT   )rU   r   rf   r   ro   s    r\   rV   zExtensionBlock.shapei  s>     99>$&&4>>"C$444r^   c                V   t        |t              r{|\  }}t        j                  |      s|dk7  rt	        |  d      t        |t
              r/|dk  r|t        | j                        z  }| j                  ||dz    S | j                  |   S |dk7  rt	        |  d      | j                  S )Nr   z only contains one itemrT   )ru   tuplecomis_null_slice
IndexErrorr   r   rf   )rX   rs   colr   s       r\   r3  zExtensionBlock.igetp  s     aHC$$S)cQh D6)@!ABBC' 73t{{++C {{3q11;;s##Av D6)@!ABB;;r^   c                d    |r| j                   j                         | _         || j                   d d  y rk   r6  r7  s       r\   r9  zExtensionBlock.set_inplace  s(     ++**,DKAr^   c                R   t        |t        j                  t        f      rE|j                  | j
                  j                  dz   k(  r|j                  d   dk(  sJ |dddf   }|S t        |t              r1|j                  d   dk(  sJ |j                  dd      j                  }|S )z@
        If necessary, squeeze a (N, 1) ndarray to (N,)
        rT   Nr   ru  )
ru   rv   rL  rD   rU   rf   rV   r0   _ixsr|  r+  s     r\   r-  z!ExtensionBlock._maybe_squeeze_arg  s     sRZZ89DKK,,q00 99Q<1$$$ ad)C 
 \* 99Q<1$$$((11(%--C
r^   c                   t        |t              rt        |      dk(  rt        d |D              rO|\  }}|j                  dk(  r%|dk(  j                         r|j
                  d   dk(  st        d      |dddf   }|S t        j                  |d         r|d   dk(  r|d   }|S t        j                  |d         r|d   }|S t        |d         r|d   d   dk(  r|d   }|S t        d      |S )zw
        Adapt a 2D-indexer to our 1D values.

        This is intended for 'setitem', not 'iget' or '_slice'.
        r   c              3  r   K   | ]/  }t        |t        j                        xr |j                  d k(   1 yw)r   N)ru   rv   rL  rU   r  s     r\   r  z9ExtensionBlock._unwrap_setitem_indexer.<locals>.<genexpr>  s+     RQz!RZZ0@QVVq[@Rs   57rT   r   zPThis should not be reached. Please report a bug at github.com/pandas-dev/pandas/N)ru   r  r   r  sizerV   r   r   
is_integerr  r  r)   )rX   r   firstseconds       r\   r/  z&ExtensionBlock._unwrap_setitem_indexer  s    gu%
 7|q R'RR$+ME6q(fk->->-@U[[QR^WXEX1<  $AqDkG"  ^^GAJ/GAJ!O%ajG  &&wqz2%ajG  "'!*-'!*Q-12D%ajG 	 .8  r^   c                     y)z,Extension arrays are never treated as views.Fri   ro   s    r\   r  zExtensionBlock.is_view  s     r^   c                B    | j                   j                  j                  S rk   )rf   rm   _is_numericro   s    r\   r  zExtensionBlock.is_numeric  s    {{  ,,,r^   r   Nc                    |t         j                  u rd}| j                  j                  ||d      }| j                  dk(  r|J || j
                  }| j                  ||      S )r;  NT)r   r=  rT   )r   r>  rf   takerU   r   r   )rX   r   r<  r   r   r   s         r\   r@  zExtensionBlock.take_nd  sm     'J [[%%g*QU%V
 IIN|';<<>>L))*lCCr^   c                    | j                   dk(  rLt        |t              st        d|      t	        d      |   }t        |      st        d|      t        d      }| j                  |   S )z
        Return a slice of my values.

        Parameters
        ----------
        slicer : slice, ndarray[int], or ndarray[bool]
            Valid (non-reducing) indexer for self.values.

        Returns
        -------
        ExtensionArray
        r   z+invalid slicing for a 1-ndim ExtensionArrayrT   N)rU   ru   r   AssertionErrorranger   rf   )rX   r   new_locss      r\   r   zExtensionBlock._slice  sp    & 99> fe,$A6  Qx'Hx=$A6  4[F{{6""r^   c                p    | j                   |   } t        |       || j                  | j                        S )zN
        Perform __getitem__-like specialized to slicing along index.
        r   )rf   r   r   rU   )rX   r   r   s      r\   getitem_block_indexz"ExtensionBlock.getitem_block_index!  s/     [[(
tDz*dnn499EEr^   c                    |dk(  r)|dk7  r$t         |   t        | j                        d      S |dk(  rd}t         |   ||      S )Nr   ru  rT   )r  rv  r   rf   )rX   rW  r<  r  s      r\   rv  zExtensionBlock.diff+  sM    19a
 7<DKK 0q<9919 Dw|At$$r^   c                `    | j                   j                  ||      }| j                  |      gS )z
        Shift the block by `periods`.

        Dispatches to underlying ExtensionArray and re-boxes in an
        ExtensionBlock.
        )ry  r   rf   rA   r   )rX   ry  r<  r   r   s        r\   rA   zExtensionBlock.shift8  s1     [[&&w:&N
**:677r^   c                *   |j                   \  }}|j                  |   }||   }t        t        ||            D 	cg c]D  \  }\  }}	 t	        |       | j
                  j                  |||   |      t        |	      d      F }
}}}	|
|fS c c}	}}w )N)r=  r   r   r   )arange_resultrE  r   r  r   rf   r  r   )rX   rG  r   rH  rI  r   r  rs   indicesplacer   s              r\   rJ  zExtensionBlock._unstackB  s     %22
D  \\$'
%d+ (1Z1O'P

 

 $#GU DJ  a(8Z !  u%

 

 t|

s   A	Br  )rs   r  r  r  r  r  )r   r  r`   rD   )r   r   r`   r  r  r  r  r  r  )r   r  r  r  rl   r  r   r  r   rV   r3  r9  r-  r/  r  r  r  r   r>  r@  r   r   r  rv  rA   rJ  r  r  s   @r\   r  r  W  s    	 NL5 58 ,*X   - - .2>>D%D D ,	D 
D6&#J&#	&#P F F%8' ,	'
 -'r^   r  c                  V    e Zd ZU ded<   ed	d       Zed
d       ZdddZddZddZ	y)
NumpyBlockr  rf   c                2    | j                   j                  duS r  N)rf   basero   s    r\   r  zNumpyBlock.is_viewo  s     {{t++r^   c                ,    t        | j                        S rk   )rF   rf   ro   s    r\   r  zNumpyBlock.array_valuest  s    4;;''r^   Nc                j    |t         k(  r| j                  j                  t               S | j                  S rk   )r   rf   r   ry   s     r\   r  zNumpyBlock.get_valuesx  s)    J;;%%j11{{r^   c                    | j                   S rk   r2  ro   s    r\   r  zNumpyBlock.values_for_json}  s    {{r^   c                    t        j                  | j                  |d      }| j                  j                  |      } t	        |       ||| j
                        S )Nr   r   )rv   r  rf   r   r   rU   r  s       r\   r  zNumpyBlock.delete  sE    4;;Q/>>((-tDz&H499EEr^   r  r  rk   r  r  r  )
r   r  r  r  r  r  r  r  r  r  ri   r^   r\   r  r  l  s>    , , ( (
Fr^   r  c                      e Zd ZdZdZy)NumericBlockri   TN)r   r  r  r  r  ri   r^   r\   r  r    s    IJr^   r  c                  T    e Zd ZU dZded<   ed	d       Zed	d       Zd
ddZ	dddZ
y)r  z8
    Block backed by an NDArrayBackedExtensionArray
    rP   rf   c                L    t        | j                  t        j                         S rk   )ru   rm   rv   ro   s    r\   r   z(NDArrayBackedExtensionBlock.is_extension  s     djj"((333r^   c                F    | j                   j                  j                  duS r  )rf   _ndarrayr  ro   s    r\   r  z#NDArrayBackedExtensionBlock.is_view  s     {{##((44r^   c                j    | j                   }||j                  ||      z
  }| j                  |      gS )a  
        1st discrete difference.

        Parameters
        ----------
        n : int
            Number of periods to diff.
        axis : int, default 0
            Axis to diff upon.

        Returns
        -------
        A list with a new Block.

        Notes
        -----
        The arguments here are mimicking shift so they are called correctly
        by apply.
        ru  )rf   rA   r   )rX   rW  r<  rf   r   s        r\   rv  z NDArrayBackedExtensionBlock.diff  s6    ( fll14l88

+,,r^   Nc                f    | j                   }|j                  |||      }| j                  |      gS )N)r   r<  r  )rX   ry  r<  r   rf   r   s         r\   rA   z!NDArrayBackedExtensionBlock.shift  s3    \\'jt\L
**:677r^   r  )r   r  r  r  )r   r  r  r  r  r   r   r  r  rv  rA   ri   r^   r\   r  r    sA     (' 4 4 5 5
-28r^   r  c                    t        | t              r.t        | t              rydt        |       v rydt        |       vr yy)z
    We catch ValueError for now, but only a specific one raised by DatetimeArray
    which will no longer be raised in version.2.0.
    z'value.closed' iszTimezones don't matchN)ru   r   r   r   )r  s    r\   r  r    sF    
 #z" c01 CH,$CH4 5 #r^   c                  ,    e Zd ZU dZdZdZded<   ddZy)	DatetimeLikeBlockz*Block for datetime64[ns], timedelta64[ns].ri   FzDatetimeArray | TimedeltaArrayrf   c                .    | j                   j                  S rk   )rf   r  ro   s    r\   r  z!DatetimeLikeBlock.values_for_json  s    {{###r^   Nr  )r   r  r  r  r  r  r  r  ri   r^   r\   r  r    s    4IJ**$r^   r  c                  D    e Zd ZU dZded<   dZdZdZdZe	j                  Z
y)DatetimeTZBlockz0implement a datetime64 block with a tz attributerC   rf   ri   TFN)r   r  r  r  r  r  r   r  rl   r  r  ri   r^   r\   r  r    s-    :ILN 2AAOr^   r  c                  V    e Zd ZdZdZeddd       Ze	 	 	 	 d	 	 	 	 	 	 	 	 	 d	d       Zy)
ObjectBlockri   Tc                   | j                   dk(  sJ 	  || j                        }t        |t        j
                        sJ |j                   dk(  sJ |j                  dd      }| j                  |      gS # t        $ r |s g cY S w xY w)z;
        For object-dtype, we operate column-wise.
        r   rT   r   )rU   rf   r   ru   rv   rL  r   r   )rX   r   r   ress       r\   r   zObjectBlock.reduce  s    
 yyA~~	t{{#C #rzz***xx1}}kk!R **3/00  	"I	s   A6 6BBc                    | j                   }|j                  dk(  r|d   }t        |||||      }t        || j                        }| j	                  |      gS )z
        attempt to cast any object types to better types return a copy of
        the block (if copy = True) by definition we ARE an ObjectBlock!!!!!
        r   r   )r   r   r   r   )rf   rU   r#   r   r   )rX   r   r   r   r   rf   r   s          r\   r   zObjectBlock.convert  sa     ;;! AYF)

 (
DII>

+,,r^   Nr  r  r  r  )r   r  r  r  r	  rb   r   r   ri   r^   r\   r  r    sp    II1 1$  -- - 	-
 - 
- -r^   r  c                  "    e Zd ZdZedd       Zy)CategoricalBlockri   c                .    | j                   j                  S rk   r   ro   s    r\   rm   zCategoricalBlock.dtype"  r   r^   Nr  )r   r  r  r  r  rm   ri   r^   r\   r  r    s    I ! !r^   r  c                4   t        | t        j                        rJt        |       } t	        | j
                  j                  t              rt        j                  | t              } t        | t        t        f      r| j                  | j                  d      } | S )a:  
    Input validation for values passed to __init__. Ensure that
    any datetime64/timedelta64 dtypes are in nanoseconds.  Ensure
    that we do not have string dtypes.

    Parameters
    ----------
    values : np.ndarray or ExtensionArray

    Returns
    -------
    values : np.ndarray or ExtensionArray
    r   N)ru   rv   rL  rK   
issubclassrm   r   r   r   rQ   rC   rH   freq
_with_freqr2  s    r\   r   r   +  sm      &"**%/7fll''-XXfF3F&=.9:v{{?V""4(Mr^   c                R   | j                   }| j                  }t        | t              rt        }|S t        | t
              rt        }|S |t        u rt        }|S t        | t              rt        }|S t        | t              rt        }|S |dv rt        }|S |dv rt        }|S t        }|S )z
    Find the appropriate Block subclass to use for the given values and dtype.

    Parameters
    ----------
    dtype : numpy or pandas dtype

    Returns
    -------
    cls : class, subclass of Block
    )r   r   )rk  crs   rt   rr   )r   rw   ru   rI   r  r,   r  r   r  r/   r  r-   r  r  r  )rm   vtyperw   clss       r\   get_block_typer!  H  s     JJE::D %%" J! 
E+	, J 
)	 J 
E;	') J 
E>	* J 
	
 J	 
*	* J Jr^   c                X    t        | j                        }t        |       }  || d|      S )Nr   rU   r   )r!  rm   r   )rf   r   klasss      r\   rF  rF  q  s+    
 6<<(E (Fa955r^   c                   t        |t              st        |      }t        | ||       t        | j                        }t        |       }  || ||      S )Nr#  )ru   r   
check_ndimr!  rm   r   )rf   r   rU   r$  s       r\   r   r   |  sK     i0"9-	vy$'6<<(E (Fdi88r^   c                   | j                   |kD  rt        d| j                    d| d      t        | j                        sf| j                   |k7  rt        d| j                    d| d      t	        |      t	        |       k7  r#t        dt	        |        dt	        |             y|dk(  rt	        |      d	k7  rt        d
      yy)aV  
    ndim inference and validation.

    Validates that values.ndim and ndim are consistent.
    Validates that len(values) and len(placement) are consistent.

    Parameters
    ----------
    values : array-like
    placement : BlockPlacement
    ndim : int

    Raises
    ------
    ValueError : the number of dimensions do not match
    z0Wrong number of dimensions. values.ndim > ndim [z > ]z1Wrong number of dimensions. values.ndim != ndim [z != zWrong number of items passed z, placement implies r   rT   zneed to splitN)rU   r   r%   rm   r   )rf   r   rU   s      r\   r&  r&    s    $ {{T##);;-s4&;
 	

 !.;;$((.}DaA  y>S[(/F} =%%(^$46  )
 
s9~*)) +r^   c                    t        | t              r,| j                         } |r|dkD  rt        j                  |       } t        |t
              r|j                  }| |fS )zL
    Ensure that we don't allow PandasArray / PandasDtype in internals.
    rT   )ru   r2   to_numpyrv   
atleast_2dr.   numpy_dtype)rf   rm   rU   s      r\   extract_pandas_arrayr-    sP     &.)"D1H]]6*F%%!!5=r^   c                   |g }t        | t              r<| D ]5  }t        |t              r|j                  |       %|j                  |       7 |S t        | t              sJ t        |              |j                  |        |S )z.return a new extended blocks, given the result)ru   listr   r   rd   r   )r   r   rs      r\   r   r     sz    ~&$ 	!A!T"a a 		! M &%(6$v,6(fMr^   c                    | j                   |k  r3t        | j                        st        d|       } | j	                  dd      } | S )z:
    Reshape if possible to have values.ndim == ndim.
    z+np.ndarray | DatetimeArray | TimedeltaArrayrT   r   )rU   r%   rm   r
   r   )rf   rU   s     r\   r   r     s@    
 {{T"6<<0 GPF^^Ar*FMr^   r  .)r   r   float_formatdecimalc               2   t        | t              ra| j                  j                  j                  dv r?t        j                  | j                  j                  t        | j                        |      } t        |       } t        | t        t        f      r| j                  dk(  r- | j                  dd|i|}|j                  t         d      }|S g }t#        t%        |             D ]C  } | |ddf   j                  dd|i|}|j'                  |j                  t         d             E t)        j*                  |      S | j                  j                  dk(  rt-        |       s|]|d	k(  rXt/        |       }	|s| j                  t0              } nt)        j2                  | d
      } || |	<   | j                  t         d      } | S ddlm}
  |
| ||||d      }|j9                         }|j                  t         d      }|S t        | t:              r:t/        |       }	t)        j<                  | j                  t                     }|||	<   |S t/        |       }	t?        j@                  |      }| j                  tB        k7  rg|se|rc| j                  t0              } | j                  jD                  t)        j                  d      jD                  z  |k  r,| j                  d|       } nt)        j2                  | d
      } || |	<   | j                  t         d      } | S )r   MmrB  rT   r   Fr   Nrk  r2  rQ   r   r   )FloatArrayFormatter)r   r3  r4  r   fixed_widthU1z<Uri   )#ru   rB   
categoriesrm   rw   r?  r@  r|  r$   _codesrK   rC   rH   rU   _format_native_typesr   rQ   r  r   r   rv   vstackr*   r6   r   r   pandas.io.formats.formatr7  get_result_as_arrayrD   r{  r   word_lenr   itemsize)rf   r   r   r3  r4  rZ   r   results_convertedrs   r  r7  	formatterr  r   rA  s                  r\   r   r     s    &+&6+<+<+B+B+G+G4+O%%.
 ,F3F&=.9:;;!0V00II&IF]]6]6FM s6{# 	HA6VAqD\66OfOOF$$V]]6]%FG	H yy*++			c	!)F*; GsN<Ds+&9!F4L]]6]6FM@'%
	 ++-jjej,
	FN	+F|ZZf 56
!
4 F|##F+<<:%g(]]3'F||$$rxx~'>'>>IH:7XXfH5FtvE2r^   c                    t        | t        t        f      r| j                  t              S t        | t
        t        f      r| j                  S | S )a+  
    The array that Series.values returns (public attribute).

    This has some historical constraints, and is overridden in block
    subclasses to return the correct array (e.g. period returns
    object ndarray and datetimetz a datetime64[ns] ndarray instead of
    proper extension array).
    )ru   rG   rE   r   rQ   rC   rH   _datar2  s    r\   r   r   B	  sB     &;67}}V$$	F]N;	< ||r^   )r[   r   r`   r   )r  	Exceptionr`   r  )rf   r   r`   r   )rm   r   )rf   r   r   r   )rU   rg   r`   rd   )r   r   rU   rg   r`   r  )rf   re   rm   r  rU   rg   r`   z3tuple[np.ndarray | ExtensionArray, DtypeObj | None]rk   r_   r  )rf   r   rU   rg   r`   r   )rf   r   r`   r  )
__future__r   	functoolsr   r  typingr   r   r   r   r	   r
   r   r}   numpyrv   pandas._libsr   r   libinternalsr   r   pandas._libs.internalsr   pandas._libs.tslibsr   pandas._typingr   r   r   r   r   r   pandas.errorsr   pandas.util._decoratorsr   pandas.util._exceptionsr   pandas.util._validatorsr   pandas.core.dtypes.astyper   pandas.core.dtypes.castr   r   r    r!   r"   r#   pandas.core.dtypes.commonr$   r%   r&   r'   r(   r)   r*   r+   pandas.core.dtypes.dtypesr,   r-   r.   r/   pandas.core.dtypes.genericr0   r1   r2   r3   pandas.core.dtypes.inferencer4   pandas.core.dtypes.missingr5   r6   r7   pandas.core.algorithmscore
algorithmsr?  pandas.core.array_algos.putmaskr8   r9   r:   r;   r<    pandas.core.array_algos.quantiler=   pandas.core.array_algos.replacer>   r?   r@   "pandas.core.array_algos.transformsrA   pandas.core.arraysrB   rC   rD   rE   rF   rG   rH   pandas.core.arrays.sparserI   pandas.core.baserJ   pandas.core.commoncommonr  #pandas.core.computation.expressionscomputationr_  pandas.core.constructionrK   rL   pandas.core.indexersrM   pandas.core.missingr  pandasrN   rO   pandas.core.arrays._mixinsrP   rm   r   rb   rd   r  r  r  r  NDArrayBackedBlockr  r  r  r  r  r  r   r!  rF  r   r&  r-  r   r   r   r   ri   r^   r\   <module>ro     s+   "  	      2 5  . 2 4 7 7 	 	 	   @  ' &  = 
 5   2 )     9 9 7 % % G RXXh
$M(L M(`&w6E w6tR\'' RjF((% F4: 
/8,"A"A= /8d"$3 $B' B1-* 1-h!~ !:&R69'*T'0?GJ8, & UU Upr^   