a
    DBìjµb  ã                   @  sr  d Z ddlmZ ddlZddlmZ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 ddlm  mZ dd	lmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& dd
l'm(Z(m)Z) ddl*m+Z+ ddl,m-Z- dddœdd„Z.dddœdd„Z/dddœdd„Z0dd„ Z1dd„ Z2e2e0e/e.e(ƒfdddœdd„Z3dd„ Z4e4e5ƒZ6e4e7ƒZ8e9dd „ d!d „ e:eƒD ƒD ƒƒZ;e;fd"d#„Z<e9d$d „ e;D ƒƒZ=e<ej>ƒZ?e<ej@ƒZAe<ejBƒZCe<ejDƒZEe<ejFƒZGe<ejHƒZIe<ejJƒZKe<ejLƒZMe<ejNƒZOe<ejPƒZQe<ejRƒZSe<ejƒZTe<ejUƒZVe9g d%¢ƒZWe9g d&¢ƒZXeAe?B eQB eSB eTB eVB eEB eXB eW ZYe=eY eWB ZZeYeZ@ Z[d'e[› �Z\e[�rˆJ e\ƒ‚dd(d)œd*d+„Z]ed,ƒZ^d-d.d/œd0d1„Z_d2d3„ Z`e e%d4œZad5d6„ Zbe_eYƒebeaƒG d7d8„ d8ejcƒƒƒZde9g d9¢ƒZee9ee ƒZfe_eYeeB eGe9g d:¢ƒB  ƒG d;d<„ d<edƒƒZge_eYeeB e9d=gƒB ƒG d>d?„ d?edƒƒZhG d@dA„ dAƒZiehegdBœZjdS )Cz
:func:`~pandas.eval` parsers.
é    )ÚannotationsN)ÚpartialÚreduce©Ú	iskeyword)ÚCallableÚClassVarÚTypeVar)ÚUndefinedVariableError)Úis_string_dtype)ÚARITH_OPS_SYMSÚBOOL_OPS_SYMSÚCMP_OPS_SYMSÚ	LOCAL_TAGÚMATHOPSÚ
REDUCTIONSÚUNARY_OPS_SYMSÚBinOpÚConstantÚFuncNodeÚOpÚTermÚUnaryOpÚis_term)Úclean_backtick_quoted_toksÚtokenize_string)ÚScope)Úprintingztuple[int, str])ÚtokÚreturnc                 C  s   | \}}||dkrdn|fS )a`  
    Rewrite the assignment operator for PyTables expressions that use ``=``
    as a substitute for ``==``.

    Parameters
    ----------
    tok : tuple of int, str
        ints correspond to the all caps constants in the tokenize module

    Returns
    -------
    tuple of int, str
        Either the input or token or the replacement values
    ú=ú==© ©r   ÚtoknumÚtokvalr"   r"   ú[/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/pandas/core/computation/expr.pyÚ_rewrite_assign3   s    r'   c                 C  sF   | \}}|t jkr>|dkr$t jdfS |dkr6t jdfS ||fS ||fS )aj  
    Replace ``&`` with ``and`` and ``|`` with ``or`` so that bitwise
    precedence is changed to boolean precedence.

    Parameters
    ----------
    tok : tuple of int, str
        ints correspond to the all caps constants in the tokenize module

    Returns
    -------
    tuple of int, str
        Either the input or token or the replacement values
    ú&Úandú|Úor)ÚtokenizeÚOPÚNAMEr#   r"   r"   r&   Ú_replace_booleansF   s    


r/   c                 C  s,   | \}}|t jkr$|dkr$t jtfS ||fS )a(  
    Replace local variables with a syntactically valid name.

    Parameters
    ----------
    tok : tuple of int, str
        ints correspond to the all caps constants in the tokenize module

    Returns
    -------
    tuple of int, str
        Either the input or token or the replacement values

    Notes
    -----
    This is somewhat of a hack in that we rewrite a string such as ``'@a'`` as
    ``'__pd_eval_local_a'`` by telling the tokenizer that ``__pd_eval_local_``
    is a ``tokenize.OP`` and to replace the ``'@'`` symbol with it.
    ú@)r,   r-   r   r#   r"   r"   r&   Ú_replace_locals_   s    
r1   c                   s   ‡ ‡fdd„S )z
    Compose 2 callables.
    c                    s   ˆ ˆ| i |¤ŽƒS ©Nr"   )ÚargsÚkwargs©ÚfÚgr"   r&   Ú<lambda>}   ó    z_compose2.<locals>.<lambda>r"   r5   r"   r5   r&   Ú	_compose2y   s    r:   c                  G  s   t | ƒdksJ dƒ‚tt| ƒS )z&
    Compose 2 or more callables.
    é   z.At least 2 callables must be passed to compose)Úlenr   r:   )Úfuncsr"   r"   r&   Ú_compose€   s    r>   Ústr)Úsourcer   c                   s,   t ˆ ƒsJ dƒ‚t ‡ fdd„t| ƒD ƒ¡S )aÒ  
    Compose a collection of tokenization functions.

    Parameters
    ----------
    source : str
        A Python source code string
    f : callable
        This takes a tuple of (toknum, tokval) as its argument and returns a
        tuple with the same structure but possibly different elements. Defaults
        to the composition of ``_rewrite_assign``, ``_replace_booleans``, and
        ``_replace_locals``.

    Returns
    -------
    str
        Valid Python source code

    Notes
    -----
    The `f` parameter can be any callable that takes *and* returns input of the
    form ``(toknum, tokval)``, where ``toknum`` is one of the constants from
    the ``tokenize`` module and ``tokval`` is a string.
    zf must be callablec                 3  s   | ]}ˆ |ƒV  qd S r2   r"   ©Ú.0Úx©r6   r"   r&   Ú	<genexpr>§   r9   z_preparse.<locals>.<genexpr>)Úcallabler,   Ú
untokenizer   ©r@   r6   r"   rD   r&   Ú	_preparseˆ   s    rI   c                   s   ‡ fdd„S )zO
    Factory for a type checking function of type ``t`` or tuple of types.
    c                   s   t | jˆ ƒS r2   )Ú
isinstanceÚvalue)rC   ©Útr"   r&   r8   ®   r9   z_is_type.<locals>.<lambda>r"   rL   r"   rL   r&   Ú_is_typeª   s    rN   c                 c  s(   | ] }t |tƒrt|tjƒr|V  qd S r2   )rJ   ÚtypeÚ
issubclassÚastÚAST©rB   Únoder"   r"   r&   rE   ¶   s   þrE   c                 c  s   | ]}t t|ƒV  qd S r2   )ÚgetattrrQ   )rB   Únamer"   r"   r&   rE   ¸   r9   c                   s   ‡ fdd„|D ƒ}t |ƒS )zE
    Filter out AST nodes that are subclasses of ``superclass``.
    c                 3  s   | ]}t |ˆ ƒr|jV  qd S r2   )rP   Ú__name__rS   ©Ú
superclassr"   r&   rE   Á   r9   z _filter_nodes.<locals>.<genexpr>)Ú	frozenset)rY   Z	all_nodesZ
node_namesr"   rX   r&   Ú_filter_nodes½   s    r[   c                 c  s   | ]}|j V  qd S r2   )rW   rA   r"   r"   r&   rE   Å   r9   )ÚAssignÚModuleÚExpr)ÚYieldÚGeneratorExpÚIfExpÚDictCompÚSetCompÚReprÚLambdaÚSetrR   ÚIsÚIsNotz$cannot both support and not support zCallable[..., None])Ú	node_namer   c                   s   ‡ fdd„}|S )zV
    Return a function that raises a NotImplementedError with a passed node name.
    c                   s   t dˆ › d�ƒ‚d S )Nú'z' nodes are not implemented)ÚNotImplementedError)Úselfr3   r4   ©ri   r"   r&   r6     s    z _node_not_implemented.<locals>.fr"   )ri   r6   r"   rm   r&   Ú_node_not_implementedþ   s    rn   Ú_Tzset[str]zCallable[[type[_T]], type[_T]])Únodesr   c                   s   dddœ‡ fdd„}|S )z‹
    Decorator to disallow certain nodes from parsing. Raises a
    NotImplementedError instead.

    Returns
    -------
    callable
    ztype[_T])Úclsr   c                   sB   d| _ ˆ D ]2}t|ƒ}d|› �}|  j |f7  _ t| ||ƒ q
| S )Nr"   Úvisit_)Úunsupported_nodesrn   Úsetattr)rq   rT   Z
new_methodrV   ©rp   r"   r&   Ú
disallowed  s    
zdisallow.<locals>.disallowedr"   )rp   rv   r"   ru   r&   Údisallow  s    
rw   c                   s   ‡ ‡fdd„}|S )zw
    Return a function to create an op class with its symbol already passed.

    Returns
    -------
    callable
    c                   s   t ˆ ˆg|¢R i |¤ŽS )z’
        Return a partial function with an Op subclass with an operator already passed.

        Returns
        -------
        callable
        )r   )rl   rT   r3   r4   ©Úop_classÚ	op_symbolr"   r&   r6   0  s    z_op_maker.<locals>.fr"   )ry   rz   r6   r"   rx   r&   Ú	_op_maker'  s    	
r{   )ÚbinaryZunaryc                   s   ‡ fdd„}|S )z9
    Decorator to add default implementation of ops.
    c                   sl   ˆ   ¡ D ]^\}}t| |› d�ƒ}t| |› d�ƒ}|D ]0}|| }|d ur4t||ƒ}t| d|› �|ƒ q4q| S )NZ_opsZ_op_nodes_maprr   )ÚitemsrU   r{   rt   )rq   Zop_attr_namery   ÚopsZops_mapÚopZop_nodeZmade_op©Ú
op_classesr"   r&   r6   E  s    
zadd_ops.<locals>.fr"   )r�   r6   r"   r€   r&   Úadd_ops@  s    r‚   c                   @  s¦  e Zd ZU dZeZded< eZded< e	e
 e ZdZeeeeƒƒZeZdZeeeeƒƒZejejejejejejejejiZded< efd	d
œdd„Zdd„ Zdd„ Zdd„ Zdd„ Z dFdd„Z!dd„ Z"dd„ Z#dGdd„Z$d d!„ Z%d"d#„ Z&d$d
œd%d&„Z'd$d
œd'd(„Z(d$d
œd)d*„Z)d$d
œd+d,„Z*d$d
œd-d.„Z+d$d
œd/d0„Z,e,Z-d1d2„ Z.d$d
œd3d4„Z/d5d
œd6d7„Z0d8d9„ Z1d:d;„ Z2dHd<d=„Z3d>d?„ Z4d@dA„ Z5dBdC„ Z6dDdE„ Z7dS )IÚBaseExprVisitorzÌ
    Custom ast walker. Parsers of other engines should subclass this class
    if necessary.

    Parameters
    ----------
    env : Scope
    engine : str
    parser : str
    preparser : callable
    zClassVar[type[Term]]Ú
const_typeÚ	term_type)ÚGtÚLtÚGtEÚLtEÚEqÚNotEqÚInÚNotInÚBitAndÚBitOrÚAndÚOrÚAddÚSubÚMultÚDivÚPowÚFloorDivÚMod)ÚUAddÚUSubÚInvertÚNotztuple[str, ...]rs   ÚNone©r   c                 C  s"   || _ || _|| _|| _d | _d S r2   )ÚenvÚengineÚparserÚ	preparserÚassigner©rl   rŸ   r    r¡   r¢   r"   r"   r&   Ú__init__Š  s
    zBaseExprVisitor.__init__c              
   K  s˜   t |tƒrn|  |¡}zt t |¡¡}W nD tyl } z,tdd„ | ¡ D ƒƒrTd|_	|‚W Y d }~n
d }~0 0 dt
|ƒj› �}t| |ƒ}||fi |¤ŽS )Nc                 s  s   | ]}t |ƒV  qd S r2   r   rA   r"   r"   r&   rE   —  r9   z(BaseExprVisitor.visit.<locals>.<genexpr>z4Python keyword not valid identifier in numexpr queryrr   )rJ   r?   r¢   rQ   Úfix_missing_locationsÚparseÚSyntaxErrorÚanyÚsplitÚmsgrO   rW   rU   )rl   rT   r4   ÚcleanÚeÚmethodÚvisitorr"   r"   r&   Úvisit‘  s    


zBaseExprVisitor.visitc                 K  s2   t |jƒdkrtdƒ‚|jd }| j|fi |¤ŽS )Nr;   z#only a single expression is allowedr   )r<   Úbodyr¨   r°   )rl   rT   r4   Úexprr"   r"   r&   Úvisit_ModuleŸ  s    
zBaseExprVisitor.visit_Modulec                 K  s   | j |jfi |¤ŽS r2   ©r°   rK   ©rl   rT   r4   r"   r"   r&   Ú
visit_Expr¥  s    zBaseExprVisitor.visit_Exprc                 C  sÂ   |j }t|ƒ}t|ƒr¬t|ƒr¬|| jv r¬tt||fƒ\}}tt||fƒ\}}	|s\|s\|s\|	rh| j| ƒ }|	rŠ| j |j	g¡}
|  
|
| j¡}|r¬| j |j	g¡}
|  
|
| j¡}|  |¡}||||fS r2   )r   rO   r   Úrewrite_mapÚmapÚ_is_listÚ_is_strrŸ   Úadd_tmprK   r…   r°   )rl   rT   ÚleftÚrightZop_instanceZop_typeÚ	left_listÚ
right_listZleft_strZ	right_strrV   r   r"   r"   r&   Ú_rewrite_membership_op¨  s    
z&BaseExprVisitor._rewrite_membership_opNc                 C  sR   |d u r| j |jdd�}|d u r0| j |jdd�}|  |||¡\}}}}||||fS )Nr¼   )Úsider½   )r°   r¼   r½   rÀ   )rl   rT   r¼   r½   r   ry   r"   r"   r&   Ú_maybe_transform_eq_neÃ  s    z&BaseExprVisitor._maybe_transform_eq_nec                 C  s˜   t  t j¡}|jrNt|dƒrN|jsN|j|krN| j t  |j¡¡}|  	|| j¡}|jr�t|dƒr�|js�|j|kr�| j t  |j¡¡}|  	|| j¡}||fS )NrK   )
ÚnpZdtypeZfloat32Z	is_scalarÚhasattrÚreturn_typerŸ   r»   rK   r…   )rl   r¼   r½   Zf32rV   r"   r"   r&   Ú_maybe_downcast_constantsË  s,    ÿþýüÿþýüz)BaseExprVisitor._maybe_downcast_constantsc                 C  s   |  | j| j| j| j|¡S r2   )ÚevaluaterŸ   r    r¡   r…   )rl   ÚbinopÚeval_in_pythonr"   r"   r&   Ú_maybe_evalâ  s    ÿzBaseExprVisitor._maybe_eval©Úinznot in©r!   z!=ú<ú>z<=z>=c                 C  sà   |||ƒ}|j r2td|j› d|j› d|j› d�ƒ‚| jdkrl|jtv rRt|ddƒs^t|ddƒrl|  || j¡S |j|v r‚|  ||¡S | jdkrÜt|dd ƒt	ksÌt
t|dd ƒƒsÌt|dd ƒt	ksÌt
t|dd ƒƒrÜ|  ||| ¡S |S )	Nz unsupported operand type(s) for z: 'z' and 'rj   ZpytablesZis_datetimeFrÅ   )Zhas_invalid_return_typeÚ	TypeErrorr   rO   r    r   rU   rÊ   Ú
binary_opsÚobjectr   )rl   r   ry   ÚlhsÚrhsrÉ   Zmaybe_eval_in_pythonÚresr"   r"   r&   Ú_maybe_evaluate_binopí  s<    	

ÿÿÿ
ÿ
þ
ý

ÿþýüz%BaseExprVisitor._maybe_evaluate_binopc                 K  s2   |   |¡\}}}}|  ||¡\}}|  ||||¡S r2   )rÂ   rÆ   rÖ   )rl   rT   r4   r   ry   r¼   r½   r"   r"   r&   Úvisit_BinOp  s    zBaseExprVisitor.visit_BinOpc                 K  s    |   |j¡}|   |j¡}||ƒS r2   )r°   r   Úoperand)rl   rT   r4   r   rØ   r"   r"   r&   Úvisit_UnaryOp  s    zBaseExprVisitor.visit_UnaryOpr   c                 K  s   | j |j| jfi |¤ŽS r2   )r…   ÚidrŸ   rµ   r"   r"   r&   Ú
visit_Name   s    zBaseExprVisitor.visit_Namec                 K  s   |   |j| j¡S r2   ©r„   rK   rŸ   rµ   r"   r"   r&   Úvisit_NameConstant$  s    z"BaseExprVisitor.visit_NameConstantc                 K  s   |   |j| j¡S r2   rÜ   rµ   r"   r"   r&   Ú	visit_Num(  s    zBaseExprVisitor.visit_Numc                 K  s   |   |j| j¡S r2   rÜ   rµ   r"   r"   r&   Úvisit_Constant+  s    zBaseExprVisitor.visit_Constantc                 K  s   | j  |j¡}|  || j ¡S r2   )rŸ   r»   Úsr…   ©rl   rT   r4   rV   r"   r"   r&   Ú	visit_Str/  s    zBaseExprVisitor.visit_Strc                   s*   ˆ j  ‡ fdd„|jD ƒ¡}ˆ  |ˆ j ¡S )Nc                   s   g | ]}ˆ   |¡ˆ jƒ‘qS r"   ©r°   rŸ   )rB   r­   ©rl   r"   r&   Ú
<listcomp>4  r9   z.BaseExprVisitor.visit_List.<locals>.<listcomp>)rŸ   r»   Úeltsr…   rá   r"   rä   r&   Ú
visit_List3  s    zBaseExprVisitor.visit_Listc                 K  s   |   |j¡S )zdf.index[4]r´   rµ   r"   r"   r&   Úvisit_Index9  s    zBaseExprVisitor.visit_Indexc           
   	   K  s–   ddl m} |  |j¡}|  |j¡}||| j| j| jd�}z|j| }W n0 tyx   ||| j| j| jd�}|| }Y n0 | j 	|¡}	| j
|	| jd�S )Nr   )Úeval)Z
local_dictr    r¡   )rŸ   )Úpandasré   r°   rK   ÚslicerŸ   r    r¡   ÚAttributeErrorr»   r…   )
rl   rT   r4   Zpd_evalrK   ZslobjÚresultÚvrÓ   rV   r"   r"   r&   Úvisit_Subscript=  s    ÿÿzBaseExprVisitor.visit_Subscriptrë   c                 K  sZ   |j }|dur|  |¡j}|j}|dur4|  |¡j}|j}|durN|  |¡j}t|||ƒS )zdf.index[slice(4,6)]N)Úlowerr°   rK   ÚupperÚsteprë   )rl   rT   r4   rð   rñ   rò   r"   r"   r&   Úvisit_SliceQ  s    zBaseExprVisitor.visit_Slicec                 K  s´   t |jƒdkrtdƒ‚t|jd tjƒs0tdƒ‚| jjdu rDtdƒ‚z| j	|jd fi |¤Ž}W n t
y~   |jd j}Y n0 t|d|ƒ| _| jdu r tdƒ‚| j	|jfi |¤ŽS )	zÄ
        support a single assignment node, like

        c = a + b

        set the assigner at the top level, must be a Name node which
        might or might not exist in the resolvers

        r;   z#can only assign a single expressionr   z5left hand side of an assignment must be a single nameNz%cannot assign without a target objectrV   z@left hand side of an assignment must be a single resolvable name)r<   Útargetsr¨   rJ   rQ   ÚNamerŸ   ÚtargetÚ
ValueErrorr°   r
   rÚ   rU   r£   rK   )rl   rT   r4   r£   r"   r"   r&   Úvisit_Assign_  s     

ÿzBaseExprVisitor.visit_Assignc           	      K  sœ   |j }|j}|j}t|tjƒr„|  |¡j}z&t||ƒ}| j 	|¡}|  
|| j¡W S  ty‚   t|tjƒr||j|kr|| Y S ‚ Y n0 tdt|ƒj› �ƒ‚d S )NzInvalid Attribute context )ÚattrrK   ÚctxrJ   rQ   ÚLoadr°   rU   rŸ   r»   r…   rì   rõ   rÚ   r÷   rO   rW   )	rl   rT   r4   rù   rK   rú   Zresolvedrî   rV   r"   r"   r&   Úvisit_Attribute}  s    
zBaseExprVisitor.visit_Attributec                   s€  t |jtjƒr(|jjdkr(ˆ  |j¡}nbt |jtjƒs@tdƒ‚nJzˆ  |j¡}W n8 t	yˆ   zt
|jjƒ}W n ty‚   ‚ Y n0 Y n0 |d u r¤td|jj› �ƒ‚t|dƒr´|j}t |t
ƒrò‡ fdd„|jD ƒ}|jrêtd|j› d�ƒ‚||Ž S ‡ fd	d„|jD ƒ}|jD ]H}t |tjƒ�s2td
|jj› d�ƒ‚|j�rˆ  |j¡ˆ jƒ||j< �qˆ j ||i |¤Ž¡}ˆ j|ˆ jd�S d S )NÚ__call__z"Only named functions are supportedzInvalid function call rK   c                   s   g | ]}ˆ   |¡‘qS r"   )r°   ©rB   Úargrä   r"   r&   rå   ª  r9   z.BaseExprVisitor.visit_Call.<locals>.<listcomp>z
Function "z$" does not support keyword argumentsc                   s   g | ]}ˆ   |¡ˆ jƒ‘qS r"   rã   rþ   rä   r"   r&   rå   ´  r9   z keyword error in function call 'rj   )rV   rŸ   )rJ   ÚfuncrQ   Ú	Attributerù   rü   rõ   rÐ   r°   r
   r   rÚ   r÷   rÄ   rK   r3   ÚkeywordsrV   Úkeywordrÿ   rŸ   r»   r…   )rl   rT   rÁ   r4   rÕ   Únew_argsÚkeyrV   r"   rä   r&   Ú
visit_Call‘  sH    
ÿ

ÿ
ÿÿzBaseExprVisitor.visit_Callc                 C  s   |S r2   r"   )rl   r   r"   r"   r&   Útranslate_InÄ  s    zBaseExprVisitor.translate_Inc              	   K  sª   |j }|j}t|ƒdkrF|  |d ¡}tj||j|d d�}|  |¡S |j}g }t||ƒD ]6\}}	|  tj	|	g||  |¡gd�¡}
|	}| 
|
¡ qZ|  tjt ¡ |d�¡S )Nr;   r   )r   r¼   r½   )Úcomparatorsr¼   r~   )r   Úvalues)r~   r  r<   r  rQ   r   r¼   r°   ÚzipÚCompareÚappendÚBoolOpr�   )rl   rT   r4   r~   Úcompsr   rÈ   r¼   r	  ÚcompÚnew_noder"   r"   r&   Úvisit_CompareÇ  s    
ÿzBaseExprVisitor.visit_Comparec                 C  s   t |ttfƒr|S |  |¡S r2   )rJ   r   r   r°   )rl   Zbopr"   r"   r&   Ú_try_visit_binopÜ  s    z BaseExprVisitor._try_visit_binopc                   s   ‡ ‡fdd„}ˆ j }t||ƒS )Nc                   s<   ˆ  | ¡}ˆ  |¡}ˆ ˆ ||¡\}}}}ˆ |ˆ j||¡S r2   )r  rÂ   rÖ   r   )rC   ÚyrÓ   rÔ   r   ry   ©rT   rl   r"   r&   r¯   â  s    

z-BaseExprVisitor.visit_BoolOp.<locals>.visitor)r	  r   )rl   rT   r4   r¯   Zoperandsr"   r  r&   Úvisit_BoolOpá  s    zBaseExprVisitor.visit_BoolOp)NN)rË   rÍ   )N)8rW   Ú
__module__Ú__qualname__Ú__doc__r   r„   Ú__annotations__r   r…   r   r   r   rÑ   Zbinary_op_nodesÚdictr
  Zbinary_op_nodes_mapr   Z	unary_opsZunary_op_nodesZunary_op_nodes_maprQ   rŠ   rŒ   r‹   r�   r·   rI   r¥   r°   r³   r¶   rÀ   rÂ   rÆ   rÊ   rÖ   r×   rÙ   rÛ   rÝ   rÞ   rß   râ   rç   Úvisit_Tuplerè   rï   ró   rø   rü   r  r  r  r  r  r"   r"   r"   r&   rƒ   S  sZ   
ü
  ù
)
3rƒ   )ÚDictr  rŒ   r�   )r  r  rŒ   r�   ÚTuplec                      s6   e Zd Zeeeeeeƒd�fddœ‡ fdd„Z	‡  Z
S )ÚPandasExprVisitorrD   r�   rž   c                   s   t ƒ  ||||¡ d S r2   ©Úsuperr¥   r¤   ©Ú	__class__r"   r&   r¥   ö  s    
zPandasExprVisitor.__init__)rW   r  r  r   rI   r>   r1   r/   r   r¥   Ú__classcell__r"   r"   r!  r&   r  ñ  s
   

þûr  rœ   c                      s,   e Zd Zddd„fddœ‡ fdd„Z‡  ZS )	ÚPythonExprVisitorNc                 C  s   | S r2   r"   rH   r"   r"   r&   r8     r9   zPythonExprVisitor.<lambda>r�   rž   c                   s   t ƒ j||||d� d S )N)r¢   r  r¤   r!  r"   r&   r¥     s    zPythonExprVisitor.__init__)N)rW   r  r  r¥   r#  r"   r"   r!  r&   r$    s   ÿr$  c                   @  s†   e Zd ZU dZded< ded< ded< dddddddœdd„Zedd„ ƒZdd„ Zddœdd„Z	ddœdd„Z
dd„ Zedd„ ƒZd	S )r^   a  
    Object encapsulating an expression.

    Parameters
    ----------
    expr : str
    engine : str, optional, default 'numexpr'
    parser : str, optional, default 'pandas'
    env : Scope, optional, default None
    level : int, optional, default 2
    r   rŸ   r?   r    r¡   Únumexprrê   Nr   zScope | NoneÚintr�   )r    r¡   rŸ   Úlevelr   c                 C  sL   || _ |pt|d d�| _|| _|| _t| | j| j| jƒ| _|  ¡ | _d S )Nr;   )r'  )	r²   r   rŸ   r    r¡   ÚPARSERSÚ_visitorr§   Úterms)rl   r²   r    r¡   rŸ   r'  r"   r"   r&   r¥     s    zExpr.__init__c                 C  s   t | jdd ƒS )Nr£   )rU   r)  rä   r"   r"   r&   r£   +  s    zExpr.assignerc                 C  s   |   | j¡S r2   )r*  rŸ   rä   r"   r"   r&   rý   /  s    zExpr.__call__rž   c                 C  s   t  | j¡S r2   )r   Zpprint_thingr*  rä   r"   r"   r&   Ú__repr__2  s    zExpr.__repr__c                 C  s
   t | jƒS r2   )r<   r²   rä   r"   r"   r&   Ú__len__5  s    zExpr.__len__c                 C  s   | j  | j¡S )z&
        Parse an expression.
        )r)  r°   r²   rä   r"   r"   r&   r§   8  s    z
Expr.parsec                 C  s2   t | jƒrt| jjgƒS tdd„ t | j¡D ƒƒS )z1
        Get the names in an expression.
        c                 s  s   | ]}|j V  qd S r2   )rV   )rB   Útermr"   r"   r&   rE   E  r9   zExpr.names.<locals>.<genexpr>)r   r*  rZ   rV   ÚcomÚflattenrä   r"   r"   r&   Únames>  s    
z
Expr.names)r%  rê   Nr   )rW   r  r  r  r  r¥   Úpropertyr£   rý   r+  r,  r§   r0  r"   r"   r"   r&   r^     s"   
    ú
r^   )Úpythonrê   )kr  Ú
__future__r   rQ   Ú	functoolsr   r   r  r   r,   Útypingr   r   r	   ÚnumpyrÃ   Zpandas.errorsr
   Zpandas.core.dtypes.commonr   Zpandas.core.commonÚcoreÚcommonr.  Zpandas.core.computation.opsr   r   r   r   r   r   r   r   r   r   r   r   r   r   Zpandas.core.computation.parsingr   r   Zpandas.core.computation.scoper   Zpandas.io.formatsr   r'   r/   r1   r:   r>   rI   rN   Úlistr¹   r?   rº   rZ   ÚdirZ
_all_nodesr[   Z_all_node_namesÚmodZ
_mod_nodesÚstmtZ_stmt_nodesr²   Z_expr_nodesÚexpr_contextZ_expr_context_nodesÚboolopZ_boolop_nodesÚoperatorZ_operator_nodesÚunaryopZ_unary_op_nodesÚcmpopZ_cmp_op_nodesÚcomprehensionZ_comprehension_nodesÚexcepthandlerZ_handler_nodesÚ	argumentsZ_arguments_nodesZ_keyword_nodesÚaliasZ_alias_nodesZ_hacked_nodesZ_unsupported_expr_nodesZ_unsupported_nodesZ_base_supported_nodesÚintersectionZ_msgrn   ro   rw   r{   Z_op_classesr‚   ÚNodeVisitorrƒ   Z_python_not_supportedZ_numexpr_supported_callsr  r$  r^   r(  r"   r"   r"   r&   Ú<module>   sº   @
ÿþ"þ












ÿÿþýüûúù÷

   ÿÿ=