a
    DBìjí9  ã                   @  sj  d Z ddlmZ ddlmZ ddlmZ ddlZddlmZm	Z	m
Z
 ddlZddlmZ ddlmZmZ ddlm  mZ dd	lmZmZ dd
lmZ ddlmZmZ erºddlmZm Z  dZ!dZ"dZ#e"e# Z$dZ%G dd„ dƒZ&G dd„ de&ƒZ'ddddœZ(G dd„ dƒZ)dd„ Z*dd„ Z+dZ,ej-ej.ej/ej0ej1ej2e*e+fZ3e4e5e,e3ƒƒZ6d Z7ej8ej9ej8ej9fZ:e4e5e7e:ƒƒZ;d!Z<ej=ej>ej?ej@ejAejBejCfZDe4e5e<eDƒƒZEd"ZFejAejBejCfZGe4e5eFeGƒƒZHi ZIe6e;eEfD ]ZJeI KeJ¡ �qÔd#d$œd%d&„ZLG d'd(„ d(e)ƒZMd#d$œd)d*„ZNd+ZOejPejQejRejRfZSe4e5eOeSƒƒZTG d,d-„ d-e)ƒZUG d.d/„ d/e)ƒZVG d0d1„ d1ƒZWdS )2z
Operator classes for eval.
é    )Úannotations)Údatetime)ÚpartialN)ÚTYPE_CHECKINGÚCallableÚLiteral)Ú	Timestamp)Úis_list_likeÚ	is_scalar)Úensure_decodedÚresult_type_many)ÚDEFAULT_GLOBALS)Úpprint_thingÚpprint_thing_encoded)ÚIterableÚIterator)ÚsumÚprodÚminÚmax)ÚsinÚcosÚexpÚlogÚexpm1Úlog1pÚsqrtÚsinhÚcoshÚtanhZarcsinZarccosZarctanZarccoshZarcsinhZarctanhÚabsÚlog10ÚfloorÚceil)Zarctan2Z__pd_eval_local_c                      s  e Zd ZU d'‡ fdd„	Zded< d(ddœdd	„Zed
dœdd„ƒZd
dœdd„Zdd„ Z	d dœdd„Z
dd„ Zddœdd„Zeddœdd„ƒZedd„ ƒZeZed
dœdd„ƒZeddœdd„ƒZedd „ ƒZejddœd!d „ƒZed"d#„ ƒZed$dœd%d&„ƒZ‡  ZS ))ÚTermNc                   s&   t |tƒstn| }tt|ƒj}||ƒS ©N)Ú
isinstanceÚstrÚConstantÚsuperr$   Ú__new__)ÚclsÚnameÚenvÚsideÚencodingÚklassZsupr_new©Ú	__class__© úZ/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/pandas/core/computation/ops.pyr*   L   s    zTerm.__new__ÚboolÚis_localÚNone©Úreturnc                 C  sB   || _ || _|| _t|ƒ}| t¡p*|tv | _|  ¡ | _	|| _
d S r%   )Ú_namer-   r.   r'   Ú
startswithÚ	LOCAL_TAGr   r6   Ú_resolve_nameÚ_valuer/   )Úselfr,   r-   r.   r/   Ztnamer3   r3   r4   Ú__init__T   s    
zTerm.__init__r'   c                 C  s   | j  td¡S )NÚ )r,   Úreplacer<   ©r?   r3   r3   r4   Ú
local_name^   s    zTerm.local_namec                 C  s
   t | jƒS r%   )r   r,   rC   r3   r3   r4   Ú__repr__b   s    zTerm.__repr__c                 O  s   | j S r%   ©Úvalue©r?   ÚargsÚkwargsr3   r3   r4   Ú__call__e   s    zTerm.__call__c                 O  s   | S r%   r3   rH   r3   r3   r4   Úevaluateh   s    zTerm.evaluatec                 C  sl   t | jƒ}| j}|| jjv r2t| jj| tƒr2d}| jj||d�}|  |¡ t	|dƒrh|j
dkrhtdƒ‚|S )NF)r6   Úndimé   z?N-dimensional objects, where N > 2, are not supported with eval)r'   rD   r6   r-   Úscoper&   ÚtypeÚresolveÚupdateÚhasattrrM   ÚNotImplementedError)r?   rD   r6   Úresr3   r3   r4   r=   k   s    
ÿ
ÿzTerm._resolve_namec                 C  s.   | j }t|tƒr$| jj| j||d� || _dS )zâ
        search order for local (i.e., @variable) variables:

        scope, key_variable
        [('locals', 'local_name'),
         ('globals', 'local_name'),
         ('locals', 'key'),
         ('globals', 'key')]
        )Ú	new_valueN)r,   r&   r'   r-   ZswapkeyrD   rG   )r?   rG   Úkeyr3   r3   r4   rR   |   s    

zTerm.updatec                 C  s
   t | jƒS r%   )r
   r>   rC   r3   r3   r4   r
   Ž   s    zTerm.is_scalarc                 C  sT   z| j jjW S  tyN   z| j jW  Y S  tyH   t| j ƒ Y  Y S 0 Y n0 d S r%   )r>   ÚvaluesÚdtypeÚAttributeErrorrP   rC   r3   r3   r4   rP   ’   s    z	Term.typec                 C  s$   t | ƒj› dt| jƒ› d| j › d�S )Nz(name=z, type=ú))rP   Ú__name__Úreprr,   rC   r3   r3   r4   Úraw¡   s    zTerm.rawc                 C  s6   z| j j }W n ty$   | j }Y n0 t|ttjfƒS r%   )rP   rZ   Ú
issubclassr   ÚnpÚ
datetime64©r?   Útr3   r3   r4   Úis_datetime¥   s
    zTerm.is_datetimec                 C  s   | j S r%   ©r>   rC   r3   r3   r4   rG   ®   s    z
Term.valuec                 C  s
   || _ d S r%   re   )r?   rV   r3   r3   r4   rG   ²   s    c                 C  s   | j S r%   ©r:   rC   r3   r3   r4   r,   ¶   s    z	Term.nameÚintc                 C  s   | j jS r%   )r>   rM   rC   r3   r3   r4   rM   º   s    z	Term.ndim)NN)NN)r\   Ú
__module__Ú__qualname__r*   Ú__annotations__r@   ÚpropertyrD   rE   rK   rL   r=   rR   r
   rP   Úreturn_typer^   rd   rG   Úsetterr,   rM   Ú__classcell__r3   r3   r1   r4   r$   K   s6   




r$   c                   @  s.   e Zd Zdd„ Zedd„ ƒZddœdd„Zd	S )
r(   c                 C  s   | j S r%   rf   rC   r3   r3   r4   r=   À   s    zConstant._resolve_namec                 C  s   | j S r%   rF   rC   r3   r3   r4   r,   Ã   s    zConstant.namer'   r8   c                 C  s
   t | jƒS r%   )r]   r,   rC   r3   r3   r4   rE   Ç   s    zConstant.__repr__N)r\   rh   ri   r=   rk   r,   rE   r3   r3   r3   r4   r(   ¿   s   
r(   ú~ú&ú|)ÚnotÚandÚorc                   @  s˜   e Zd ZU dZded< dddddœdd	„Zd
dœdd„Zddœdd„Zedd„ ƒZ	eddœdd„ƒZ
edd„ ƒZeddœdd„ƒZeddœdd„ƒZdS )ÚOpz.
    Hold an operator of arbitrary arity.
    r'   ÚopNzIterable[Term | Op]r7   )rv   Úoperandsr9   c                 C  s   t  ||¡| _|| _|| _d S r%   )Ú_bool_op_mapÚgetrv   rw   r/   )r?   rv   rw   r/   r3   r3   r4   r@   ×   s    zOp.__init__r   r8   c                 C  s
   t | jƒS r%   )Úiterrw   rC   r3   r3   r4   Ú__iter__Ü   s    zOp.__iter__c                 C  s(   dd„ | j D ƒ}td| j› d� |¡ƒS )zW
        Print a generic n-ary operator and its operands using infix notation.
        c                 s  s   | ]}d t |ƒ› d�V  qdS )ú(r[   N)r   )Ú.0Zoprr3   r3   r4   Ú	<genexpr>ä   ó    zOp.__repr__.<locals>.<genexpr>ú )rw   r   rv   Újoin)r?   Zparenedr3   r3   r4   rE   ß   s    zOp.__repr__c                 C  s,   | j tt v rtjS tdd„ t | ¡D ƒŽ S )Nc                 s  s   | ]}|j V  qd S r%   ©rP   ©r}   Útermr3   r3   r4   r~   ì   r   z!Op.return_type.<locals>.<genexpr>)rv   ÚCMP_OPS_SYMSÚBOOL_OPS_SYMSr`   Úbool_r   ÚcomÚflattenrC   r3   r3   r4   rl   ç   s    zOp.return_typer5   c                 C  s(   | j }tt d¡gƒ}| jtko&|| S )NÚobject)Úoperand_typesÚ	frozensetr`   rY   rl   rŠ   )r?   ÚtypesZobj_dtype_setr3   r3   r4   Úhas_invalid_return_typeî   s    zOp.has_invalid_return_typec                 C  s   t dd„ t | ¡D ƒƒS )Nc                 s  s   | ]}|j V  qd S r%   r‚   rƒ   r3   r3   r4   r~   ö   r   z#Op.operand_types.<locals>.<genexpr>)rŒ   rˆ   r‰   rC   r3   r3   r4   r‹   ô   s    zOp.operand_typesc                 C  s   t dd„ | jD ƒƒS )Nc                 s  s   | ]}|j V  qd S r%   )r
   )r}   Úoperandr3   r3   r4   r~   ú   r   zOp.is_scalar.<locals>.<genexpr>)Úallrw   rC   r3   r3   r4   r
   ø   s    zOp.is_scalarc                 C  s6   z| j j}W n ty$   | j }Y n0 t|ttjfƒS r%   )rl   rP   rZ   r_   r   r`   ra   rb   r3   r3   r4   rd   ü   s
    zOp.is_datetime)N)r\   rh   ri   Ú__doc__rj   r@   r{   rE   rk   rl   rŽ   r‹   r
   rd   r3   r3   r3   r4   ru   Ð   s   


ru   c                 C  sX   z|   |¡W S  tyR   t| ƒrFz|  | ¡W  Y S  tyD   Y n0 | |v  Y S 0 dS )z`
    Compute the vectorized membership of ``x in y`` if possible, otherwise
    use Python.
    N©ÚisinrZ   r	   ©ÚxÚyr3   r3   r4   Ú_in  s    r—   c                 C  s\   z|   |¡ W S  tyV   t| ƒrJz|  | ¡ W  Y S  tyH   Y n0 | |v Y S 0 dS )zd
    Compute the vectorized membership of ``x not in y`` if possible,
    otherwise use Python.
    Nr’   r”   r3   r3   r4   Ú_not_in  s    r˜   )ú>ú<z>=z<=z==z!=Úinznot in)rp   rq   rs   rt   )ú+ú-Ú*ú/ú**ú//ú%)r    r¡   r¢   r5   r8   c                 C  s
   t | tƒS r%   )r&   r$   )Úobjr3   r3   r4   Úis_termO  s    r¤   c                      sT   e Zd ZdZdddœ‡ fdd„Zdd„ Zdd	œd
d„Zddœdd„Zdd„ Z‡  Z	S )ÚBinOpzˆ
    Hold a binary operator and its operands.

    Parameters
    ----------
    op : str
    lhs : Term or Op
    rhs : Term or Op
    r'   r7   ©rv   r9   c              
     sŒ   t ƒ  |||f¡ || _|| _|  ¡  |  ¡  zt| | _W nJ ty† } z2t	t 
¡ ƒ}tdt|ƒ› d|› �ƒ|‚W Y d }~n
d }~0 0 d S )NzInvalid binary operator ú, valid operators are )r)   r@   ÚlhsÚrhsÚ_disallow_scalar_only_bool_opsÚconvert_valuesÚ_binary_ops_dictÚfuncÚKeyErrorÚlistÚkeysÚ
ValueErrorr]   )r?   rv   r¨   r©   Úerrr°   r1   r3   r4   r@   ^  s    ÿþzBinOp.__init__c                 C  s    |   |¡}|  |¡}|  ||¡S )zã
        Recursively evaluate an expression in Python space.

        Parameters
        ----------
        env : Scope

        Returns
        -------
        object
            The result of an evaluated expression.
        )r¨   r©   r­   )r?   r-   ÚleftÚrightr3   r3   r4   rK   p  s    

zBinOp.__call__)Úenginec                 C  sŒ   |dkr| |ƒ}nd| j j|||||d�}| jj|||||d�}| j|v rZ|  |j|j¡}nddlm}	 |	| |||d�}| |¡}
||
|d�S )al  
        Evaluate a binary operation *before* being passed to the engine.

        Parameters
        ----------
        env : Scope
        engine : str
        parser : str
        term_type : type
        eval_in_python : list

        Returns
        -------
        term_type
            The "pre-evaluated" expression as an instance of ``term_type``
        Úpython)rµ   ÚparserÚ	term_typeÚeval_in_pythonr   )Úeval)Z
local_dictrµ   r·   ©r-   )	r¨   rL   r©   rv   r­   rG   Zpandas.core.computation.evalrº   Zadd_tmp)r?   r-   rµ   r·   r¸   r¹   rU   r³   r´   rº   r,   r3   r3   r4   rL   ƒ  s,    
ûû	

zBinOp.evaluater8   c                   sæ   ‡ fdd„}ˆ j ˆ j }}t|ƒr~|jr~t|ƒr~|jr~|j}t|ttfƒrR||ƒ}t	t
|ƒƒ}|jdurr| d¡}ˆ j |¡ t|ƒrâ|jrât|ƒrâ|jrâ|j}t|ttfƒr¶||ƒ}t	t
|ƒƒ}|jdurÖ| d¡}ˆ j  |¡ dS )zK
        Convert datetimes to a comparable value in an expression.
        c                   s&   ˆ j d urttˆ j d�}nt}|| ƒS )N)r/   )r/   r   r   r   )rG   ÚencoderrC   r3   r4   Ú	stringify¹  s    
z'BinOp.convert_values.<locals>.stringifyNÚUTC)r¨   r©   r¤   rd   r
   rG   r&   rg   Úfloatr   r   ÚtzZ
tz_convertrR   )r?   r½   r¨   r©   Úvr3   rC   r4   r«   ´  s$    



zBinOp.convert_valuesc                 C  sr   | j }| j}|j}t|d|ƒ}|j}t|d|ƒ}|js<|jrn| jtv rnt|tt	j
fƒrft|tt	j
fƒsntdƒ‚d S )NrP   z$cannot evaluate scalar only bool ops)r©   r¨   rl   Úgetattrr
   rv   Ú_bool_ops_dictr_   r5   r`   r‡   rT   )r?   r©   r¨   Zrhs_rtZlhs_rtr3   r3   r4   rª   Õ  s"    ÿÿþûú
z$BinOp._disallow_scalar_only_bool_ops)
r\   rh   ri   r‘   r@   rK   rL   r«   rª   rn   r3   r3   r1   r4   r¥   S  s   
1!r¥   c                 C  s   t t | ¡jtjƒS r%   )r_   r`   rY   rP   Únumber)rY   r3   r3   r4   Ú	isnumericë  s    rÅ   )rœ   r�   ro   rr   c                      sV   e Zd ZdZdddœ‡ fdd„Zddœd	d
„Zddœdd„Zeddœdd„ƒZ‡  Z	S )ÚUnaryOpaK  
    Hold a unary operator and its operands.

    Parameters
    ----------
    op : str
        The token used to represent the operator.
    operand : Term or Op
        The Term or Op operand to the operator.

    Raises
    ------
    ValueError
        * If no function associated with the passed operator token is found.
    zLiteral['+', '-', '~', 'not']r7   r¦   c              
     sh   t ƒ  ||f¡ || _zt| | _W n> tyb } z&tdt|ƒ› dt› �ƒ|‚W Y d }~n
d }~0 0 d S )NzInvalid unary operator r§   )	r)   r@   r�   Ú_unary_ops_dictr­   r®   r±   r]   ÚUNARY_OPS_SYMS)r?   rv   r�   r²   r1   r3   r4   r@     s    ÿÿýzUnaryOp.__init__ÚMathCallr8   c                 C  s   |   |¡}|  |¡S r%   )r�   r­   )r?   r-   r�   r3   r3   r4   rK     s    
zUnaryOp.__call__r'   c                 C  s   t | j› d| j› d�ƒS )Nr|   r[   )r   rv   r�   rC   r3   r3   r4   rE     s    zUnaryOp.__repr__znp.dtypec                 C  sR   | j }|jt d¡kr t d¡S t|tƒrH|jtv s>|jtv rHt d¡S t d¡S )Nr5   rg   )	r�   rl   r`   rY   r&   ru   rv   Ú_cmp_ops_dictrÃ   )r?   r�   r3   r3   r4   rl     s    

ÿÿ
zUnaryOp.return_type)
r\   rh   ri   r‘   r@   rK   rE   rk   rl   rn   r3   r3   r1   r4   rÆ   ô  s   rÆ   c                      s8   e Zd Zddœ‡ fdd„Zdd„ Zddœdd	„Z‡  ZS )
rÉ   r7   r8   c                   s   t ƒ  |j|¡ || _d S r%   )r)   r@   r,   r­   )r?   r­   rI   r1   r3   r4   r@   &  s    zMathCall.__init__c                   s    ‡ fdd„| j D ƒ}| jj|Ž S )Nc                   s   g | ]}|ˆ ƒ‘qS r3   r3   )r}   rv   r»   r3   r4   Ú
<listcomp>,  r   z%MathCall.__call__.<locals>.<listcomp>)rw   r­   )r?   r-   rw   r3   r»   r4   rK   *  s    zMathCall.__call__r'   c                 C  s(   t t| jƒ}t| j› dd |¡› d�ƒS )Nr|   ú,r[   )Úmapr'   rw   r   rv   r�   )r?   rw   r3   r3   r4   rE   /  s    zMathCall.__repr__)r\   rh   ri   r@   rK   rE   rn   r3   r3   r1   r4   rÉ   %  s   rÉ   c                   @  s*   e Zd Zdddœdd„Zddœdd	„Zd
S )ÚFuncNoder'   r7   )r,   r9   c                 C  s.   |t vrtd|› d�ƒ‚|| _tt|ƒ| _d S )Nú"z" is not a supported function)ÚMATHOPSr±   r,   rÂ   r`   r­   )r?   r,   r3   r3   r4   r@   5  s    zFuncNode.__init__rÉ   r8   c                 G  s
   t | |ƒS r%   )rÉ   )r?   rI   r3   r3   r4   rK   ;  s    zFuncNode.__call__N)r\   rh   ri   r@   rK   r3   r3   r3   r4   rÎ   4  s   rÎ   )Xr‘   Ú
__future__r   r   Ú	functoolsr   ÚoperatorÚtypingr   r   r   Únumpyr`   Zpandas._libs.tslibsr   Zpandas.core.dtypes.commonr	   r
   Zpandas.core.commonÚcoreÚcommonrˆ   Zpandas.core.computation.commonr   r   Zpandas.core.computation.scoper   Zpandas.io.formats.printingr   r   Úcollections.abcr   r   Z
REDUCTIONSZ_unary_math_opsZ_binary_math_opsrÐ   r<   r$   r(   rx   ru   r—   r˜   r…   ÚgtÚltÚgeÚleÚeqÚneZ_cmp_ops_funcsÚdictÚziprÊ   r†   Úand_Úor_Z_bool_ops_funcsrÃ   ZARITH_OPS_SYMSÚaddÚsubÚmulÚtruedivÚpowÚfloordivÚmodZ_arith_ops_funcsZ_arith_ops_dictZSPECIAL_CASE_ARITH_OPS_SYMSZ_special_case_arith_ops_funcsZ_special_case_arith_ops_dictr¬   ÚdrR   r¤   r¥   rÅ   rÈ   ÚposÚnegÚinvertZ_unary_ops_funcsrÇ   rÆ   rÉ   rÎ   r3   r3   r3   r4   Ú<module>   s†   t6ø
ù	ÿ 1