B
    W0d@                 @  sp  d dl mZ d dlmZmZmZmZ d dlZd dl	m
Z
mZ d dlmZmZmZmZmZmZ d dlmZ d dlmZmZ 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'm(Z( d dl)mZm*Z* d dl+m,Z,m-Z-m.Z. d dl/m0Z0 d dl1m2Z2 d dl3m4Z4 d dl5m6Z6 er>d dl7m8Z8 d dl3m9Z9 edddZ:G dd deZ;G dd de2e4Z<dS )    )annotations)TYPE_CHECKINGAnySequenceTypeVarN)libmissing)	ArrayLikeDtypeNpDtypePositionalIndexerScalartype_t)AbstractMethodError)cache_readonlydoc)validate_fillna_kwargs)ExtensionDtype)is_dtype_equal
is_integeris_object_dtype	is_scalaris_string_dtypepandas_dtype)is_array_like)isnanotna)r   nanops)factorize_arrayisintake)masked_reductions)OpsMixin)ExtensionArray)check_array_indexer)Series)BooleanArrayBaseMaskedArrayTBaseMaskedArray)boundc               @  st   e Zd ZU dZded< dZded< ejZe	dddd	Z
e	ddd
dZe	ddddZeddddZdS )BaseMaskedDtypez@
    Base class for dtypes for BasedMaskedArray subclasses.
    strnameNtypeznp.dtype)returnc             C  s   t | jS )z%Return an instance of our numpy dtype)npdtyper-   )self r2   K/var/www/html/venv/lib/python3.7/site-packages/pandas/core/arrays/masked.pynumpy_dtypeO   s    zBaseMaskedDtype.numpy_dtypec             C  s   | j jS )N)r4   kind)r1   r2   r2   r3   r5   T   s    zBaseMaskedDtype.kindintc             C  s   | j jS )z(Return the number of bytes in this dtype)r4   itemsize)r1   r2   r2   r3   r7   X   s    zBaseMaskedDtype.itemsizeztype_t[BaseMaskedArray]c             C  s   t dS )zq
        Return the array type associated with this dtype.

        Returns
        -------
        type
        N)NotImplementedError)clsr2   r2   r3   construct_array_type]   s    	z$BaseMaskedDtype.construct_array_type)__name__
__module____qualname____doc____annotations__base
libmissingNAna_valuer   r4   r5   r7   classmethodr:   r2   r2   r2   r3   r*   D   s   
r*   c               @  s  e Zd ZU dZded< dZdddddd	Zed
dddZdddddZe	e
jd[dddddZddddZddddZdd Zd dd!d"Zdddd#d$Zddejfd%dddd&d'd(Zd\d*dd+d,d-d.Zd/Zd]d%dd0d1d2Zd^d3d4Zeddd5d6Zddd7d8Zed9d: Zed dd;d<Zed=d>dd?d@dAZdddBdddCddDdEdFZdGddHdIZddddJdKZ e	e
j!d_d dMdNdOdPZ!d`ddQdRdSdTZ"d)dUdVddWdXdYZ#dS )ar(   zf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   _internal_fill_valueFz
np.ndarraybool)valuesmaskcopyc             C  sh   t |tjr|jtjks td|jdkr2td|jdkrDtd|rX| }| }|| _	|| _
d S )NzGmask should be boolean numpy array. Use the 'pd.array' function instead   zvalues must be a 1D arrayzmask must be a 1D array)
isinstancer/   Zndarrayr0   bool_	TypeErrorndim
ValueErrorrI   _data_mask)r1   rG   rH   rI   r2   r2   r3   __init__s   s    

zBaseMaskedArray.__init__r*   )r.   c             C  s   t | d S )N)r   )r1   r2   r2   r3   r0      s    zBaseMaskedArray.dtyper   zBaseMaskedArray | Any)itemr.   c             C  sH   t |r$| j| r| jjS | j| S t| |}t| | j| | j| S )N)r   rQ   r0   rC   rP   r$   r-   )r1   rS   r2   r2   r3   __getitem__   s    


zBaseMaskedArray.__getitem__Nr'   )r1   r.   c             C  s   t ||\}}| j}t|rPt|t| krHtdt| dt|  || }| r|d k	rt|}|| j	 ||	 d\}}t
| ||tjS | 	 }|||< n| 	 }|S )Nz'Length of 'value' does not match. Got (z)  expected )limitrH   )r   rQ   r   lenrO   anyr   Zget_fill_funcrP   rI   r-   viewr/   rL   )r1   valuemethodrU   rH   func
new_valuesZnew_maskr2   r2   r3   fillna   s&    

zBaseMaskedArray.fillnaztuple[np.ndarray, np.ndarray]c             C  s   t | d S )N)r   )r1   rG   r2   r2   r3   _coerce_to_array   s    z BaseMaskedArray._coerce_to_arrayNonec             C  sV   t |}|r|g}| |\}}|r4|d }|d }t| |}|| j|< || j|< d S )Nr   )r   r^   r$   rP   rQ   )r1   keyrY   Z
_is_scalarrH   r2   r2   r3   __setitem__   s    

zBaseMaskedArray.__setitem__c             c  s<   x6t t| D ]&}| j| r(| jjV  q| j| V  qW d S )N)rangerV   rQ   r0   rC   rP   )r1   ir2   r2   r3   __iter__   s    
zBaseMaskedArray.__iter__r6   c             C  s
   t | jS )N)rV   rP   )r1   r2   r2   r3   __len__   s    zBaseMaskedArray.__len__c             C  s   t | | j | j S )N)r-   rP   rQ   rI   )r1   r2   r2   r3   
__invert__   s    zBaseMaskedArray.__invert__zNpDtype | None)r0   rI   rC   r.   c             C  sx   |t jkrtj}|dkrt}| jrdt|sLt|sL|tjkrLtd| d| j	
|}||| j< n| j	j
||d}|S )aF  
        Convert to a NumPy Array.

        By default converts to an object-dtype NumPy array. Specify the `dtype` and
        `na_value` keywords to customize the conversion.

        Parameters
        ----------
        dtype : dtype, default object
            The numpy dtype to convert to.
        copy : bool, default False
            Whether to ensure that the returned value is a not a view on
            the array. Note that ``copy=False`` does not *ensure* that
            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
            a copy is made, even if not strictly necessary. This is typically
            only possible when no missing values are present and `dtype`
            is the equivalent numpy dtype.
        na_value : scalar, optional
             Scalar missing value indicator to use in numpy array. Defaults
             to the native missing value indicator of this array (pd.NA).

        Returns
        -------
        numpy.ndarray

        Examples
        --------
        An object-dtype is the default result

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a.to_numpy()
        array([True, False, <NA>], dtype=object)

        When no missing values are present, an equivalent dtype can be used.

        >>> pd.array([True, False], dtype="boolean").to_numpy(dtype="bool")
        array([ True, False])
        >>> pd.array([1, 2], dtype="Int64").to_numpy("int64")
        array([1, 2])

        However, requesting such dtype will raise a ValueError if
        missing values are present and the default missing value :attr:`NA`
        is used.

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a
        <BooleanArray>
        [True, False, <NA>]
        Length: 3, dtype: boolean

        >>> a.to_numpy(dtype="bool")
        Traceback (most recent call last):
        ...
        ValueError: cannot convert to bool numpy array in presence of missing values

        Specify a valid `na_value` instead

        >>> a.to_numpy(dtype="bool", na_value=False)
        array([ True, False, False])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.)rI   )r   
no_defaultrA   rB   object_hasnar   r   rO   rP   astyperQ   )r1   r0   rI   rC   datar2   r2   r3   to_numpy   s    B

zBaseMaskedArray.to_numpyTr
   r	   )r0   rI   r.   c             C  s   t |}t|| jr$|r |  S | S t|trp| jj|j|d}|| jkrP| j	n| j	 }|
 }|||ddS t|tr|
 }|j| ||dS tdd S )N)rI   F)r0   rI   z*subclass must implement astype to np.dtype)r   r   r0   rI   rK   r*   rP   rj   r4   rQ   r:   r   Z_from_sequencer8   )r1   r0   rI   rk   rH   r9   Zeaclsr2   r2   r3   rj   0  s    

zBaseMaskedArray.astypei  )r0   r.   c             C  s   | j |dS )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        )r0   )rl   )r1   r0   r2   r2   r3   	__array__J  s    zBaseMaskedArray.__array__c             C  s   ddl }|j| j| j|dS )z6
        Convert myself into a pyarrow Array.
        r   N)rH   r-   )ZpyarrowarrayrP   rQ   )r1   r-   par2   r2   r3   __arrow_array__Q  s    zBaseMaskedArray.__arrow_array__c             C  s
   | j  S )N)rQ   rW   )r1   r2   r2   r3   ri   Y  s    zBaseMaskedArray._hasnac             C  s
   | j  S )N)rQ   rI   )r1   r2   r2   r3   r   b  s    zBaseMaskedArray.isnac             C  s   | j jS )N)r0   rC   )r1   r2   r2   r3   	_na_valuee  s    zBaseMaskedArray._na_valuec             C  s   | j j| jj S )N)rP   nbytesrQ   )r1   r2   r2   r3   rr   i  s    zBaseMaskedArray.nbytesztype[BaseMaskedArrayT]zSequence[BaseMaskedArrayT])r9   	to_concatr.   c             C  s2   t dd |D }t dd |D }| ||S )Nc             S  s   g | ]
}|j qS r2   )rP   ).0xr2   r2   r3   
<listcomp>q  s    z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>c             S  s   g | ]
}|j qS r2   )rQ   )rt   ru   r2   r2   r3   rv   r  s    )r/   concatenate)r9   rs   rk   rH   r2   r2   r3   _concat_same_typem  s    z!BaseMaskedArray._concat_same_type)
allow_fill
fill_valuezScalar | None)r1   ry   rz   r.   c            C  sr   t |r| jn|}t| j|||d}t| j|d|d}|r`t|r`t|dk}|||< ||A }t| ||ddS )N)rz   ry   TF)rI   )	r   rE   r    rP   rQ   r   r/   asarrayr-   )r1   Zindexerry   rz   Zdata_fill_valueresultrH   Z	fill_maskr2   r2   r3   r    u  s    	zBaseMaskedArray.taker&   c               sr   ddl m} t|}t j|} jrRt|joFt	 fdd|D }|| j
< tj jjtd}|||ddS )Nr   )r&   c             3  s   | ]}| j jkV  qd S )N)r0   rC   )rt   val)r1   r2   r3   	<genexpr>  s    z'BaseMaskedArray.isin.<locals>.<genexpr>)r0   F)rI   )pandas.core.arraysr&   r/   r|   r   rP   ri   r   r0   rW   rQ   zerosshaperF   )r1   rG   r&   Z
values_arrr}   Zvalues_have_NArH   r2   )r1   r3   r     s    

zBaseMaskedArray.isinc             C  s0   | j | j }}| }| }t| ||ddS )NF)rI   )rP   rQ   rI   r-   )r1   rk   rH   r2   r2   r3   rI     s    zBaseMaskedArray.copyr{   z!tuple[np.ndarray, ExtensionArray])na_sentinelr.   c             C  sT   | j }| j}t|||d\}}|j| jjdd}t| |tjt	|t
d}||fS )N)r   rH   F)rI   )r0   )rP   rQ   r   rj   r0   r4   r-   r/   r   rV   rF   )r1   r   ZarrrH   codesZuniquesr2   r2   r3   	factorize  s    zBaseMaskedArray.factorizer%   )dropnar.   c       
      C  s   ddl m}m} ddlm} | j| j  }|| }|jj	
t}|rP|j	}nVtjt|d dd}||dd< | j |d< |t|tj| jjgtdgtd}tjt|d	d}	|||	}|||d
S )aA  
        Returns a Series containing counts of each unique value.

        Parameters
        ----------
        dropna : bool, default True
            Don't include counts of missing values.

        Returns
        -------
        counts : Series

        See Also
        --------
        Series.value_counts
        r   )Indexr%   )IntegerArrayrJ   Zint64)r0   Nr{   rF   )index)pandasr   r%   Zpandas.arraysr   rP   rQ   value_countsr   Z_valuesrj   rh   r/   emptyrV   sumrw   rn   r0   rC   r   )
r1   r   r   r%   r   rk   r   r   countsrH   r2   r2   r3   r     s     
zBaseMaskedArray.value_counts)skipnar+   )r,   r   c            K  s   | j }| j}|dkr4tt|}|||fd|i|S | jrJ| jdtjd}ttd| }||fd||d|}t	|rt
jS |S )N>   prodminmeanr   maxr   Zfloat64)rC   nanr   )Zaxisr   rH   )rP   rQ   getattrr!   ri   rl   r/   r   r   isnanrA   rB   )r1   r,   r   kwargsrk   rH   opr}   r2   r2   r3   _reduce  s    

zBaseMaskedArray._reduce)F)NNN)T)N)N)r{   )T)$r;   r<   r=   r>   r?   rR   propertyr0   rT   r   r#   r]   r^   ra   rd   re   rf   r   rg   rl   rj   Z__array_priority__rm   rp   ri   r   rq   rr   rD   rx   r    r   rI   r   r   r   r2   r2   r2   r3   r(   i   s@   

V
	2)=
__future__r   typingr   r   r   r   numpyr/   Zpandas._libsr   r   rA   Zpandas._typingr	   r
   r   r   r   r   Zpandas.errorsr   Zpandas.util._decoratorsr   r   Zpandas.util._validatorsr   Zpandas.core.dtypes.baser   Zpandas.core.dtypes.commonr   r   r   r   r   r   Zpandas.core.dtypes.inferencer   Zpandas.core.dtypes.missingr   r   Zpandas.corer   Zpandas.core.algorithmsr   r   r    Zpandas.core.array_algosr!   Zpandas.core.arrayliker"   r   r#   Zpandas.core.indexersr$   r   r%   r&   r'   r*   r(   r2   r2   r2   r3   <module>   s.     %