o
    �¨Êhèa  ã                   @  sB  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  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+ dCdd„Z,dCdd„Z-dCdd„Z.dd„ Z/dd„ Z0e0e.e-e,e&ƒfdDdd„Z1dd„ Z2e2e3ƒZ4e2e5ƒZ6e7dd „ d!d „ e8eƒD ƒD ƒƒZ9e9fd"d#„Z:e7d$d „ e9D ƒƒZ;e:ej<ƒ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jƒZRe:ejSƒZTe7g d%¢ƒZUe7g d&¢ƒZVe?e=B eOB eQB eRB eTB eCB eVB eU ZWe;eW eUB ZXeWeX@ ZYd'eY› �ZZeY�r2J eZƒ‚dEd*d+„Z[ed,ƒZ\dFd0d1„Z]d2d3„ Z^ee#d4œZ_d5d6„ Z`e]eWƒe`e_ƒG d7d8„ d8ejaƒƒƒZbe7g d9¢ƒZce7ee ƒZde]eWecB eEe7g d:¢ƒB  ƒG d;d<„ d<ebƒƒZee]eWecB e7d=gƒB ƒG d>d?„ d?ebƒƒZfG d@dA„ dAƒZgefeedBœZhdS )Gz
:func:`~pandas.eval` parsers.
é    )ÚannotationsN)ÚpartialÚreduce©Ú	iskeyword)ÚCallableÚClassVarÚTypeVar)ÚUndefinedVariableError)Ú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)ÚprintingÚtokútuple[int, str]Úreturnc                 C  s   | \}}||dkrdfS |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"   úN/var/www/html/env/lib/python3.10/site-packages/pandas/core/computation/expr.pyÚ_rewrite_assign1   s   r'   c                 C  sF   | \}}|t jkr|dkrt jdfS |dkrt 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_booleansD   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>{   s    z_compose2.<locals>.<lambda>r"   r5   r"   r5   r&   Ú	_compose2w   ó   r9   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   r9   )Úfuncsr"   r"   r&   Ú_compose~   s   
r>   ÚsourceÚstrc                   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>¥   ó   € z_preparse.<locals>.<genexpr>)Úcallabler,   Ú
untokenizer   ©r?   r6   r"   rD   r&   Ú	_preparse†   s   rJ   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   ¬   s    z_is_type.<locals>.<lambda>r"   rM   r"   rM   r&   Ú_is_type¨   s   rO   c                 c  s*   � | ]}t |tƒrt|tjƒr|V  qd S r2   )rK   ÚtypeÚ
issubclassÚastÚAST©rB   Únoder"   r"   r&   rE   ´   s   € ý
ý
ÿrE   c                 c  s   � | ]}t t|ƒV  qd S r2   )ÚgetattrrR   )rB   Únamer"   r"   r&   rE   ¶   s   € 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   )rQ   Ú__name__rT   ©Ú
superclassr"   r&   rE   ¿   s   € z _filter_nodes.<locals>.<genexpr>)Ú	frozenset)rZ   Ú	all_nodesÚ
node_namesr"   rY   r&   Ú_filter_nodes»   s   r^   c                 c  ó   � | ]}|j V  qd S r2   )rX   rA   r"   r"   r&   rE   Ã   ó   € )ÚAssignÚModuleÚExpr)ÚYieldÚGeneratorExpÚIfExpÚDictCompÚSetCompÚReprÚLambdaÚSetrS   ÚIsÚIsNotz$cannot both support and not support Ú	node_nameúCallable[..., None]c                   ó   ‡ fdd„}|S )zV
    Return a function that raises a NotImplementedError with a passed node name.
    c                   s   t dˆ › d�ƒ‚)Nú'z' nodes are not implemented)ÚNotImplementedError)Úselfr3   r4   ©rn   r"   r&   r6     ó   z _node_not_implemented.<locals>.fr"   )rn   r6   r"   rt   r&   Ú_node_not_implementedü   s   rv   Ú_TÚnodesúset[str]úCallable[[type[_T]], type[_T]]c                   s   d‡ fdd„}|S )z‹
    Decorator to disallow certain nodes from parsing. Raises a
    NotImplementedError instead.

    Returns
    -------
    callable
    Úclsútype[_T]r   c                   sB   d| _ ˆ D ]}t|ƒ}d|› �}|  j |f7  _ t| ||ƒ q| S )Nr"   Úvisit_)Úunsupported_nodesrv   Úsetattr)r{   rU   Ú
new_methodrW   ©rx   r"   r&   Ú
disallowed  s   
zdisallow.<locals>.disallowedN)r{   r|   r   r|   r"   )rx   r‚   r"   r�   r&   Údisallow  s   
rƒ   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   )rs   rU   r3   r4   ©Úop_classÚ	op_symbolr"   r&   r6   .  s   z_op_maker.<locals>.fr"   )r…   r†   r6   r"   r„   r&   Ú	_op_maker%  s   	
r‡   )ÚbinaryÚunaryc                   rp   )z9
    Decorator to add default implementation of ops.
    c                   sl   ˆ   ¡ D ]/\}}t| |› d�ƒ}t| |› d�ƒ}|D ]}|| }|d ur2t||ƒ}t| d|› �|ƒ qq| S )NÚ_opsÚ_op_nodes_mapr}   )ÚitemsrV   r‡   r   )r{   Úop_attr_namer…   ÚopsÚops_mapÚopÚop_nodeÚmade_op©Ú
op_classesr"   r&   r6   C  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dFdd„Zdd„ Zdd„ Zdd„ Zdd„ Z dGdd„Z!dd„ Z"dd„ Z#		dHdd„Z$d d!„ Z%d"d#„ Z&dId%d&„Z'dId'd(„Z(dId)d*„Z)dId+d,„Z*dId-d.„Z+dId/d0„Z,e,Z-d1d2„ Z.dId3d4„Z/dJd6d7„Z0d8d9„ Z1d:d;„ Z2dKd<d=„Z3d>d?„ Z4d@dA„ Z5dBdC„ Z6dDdE„ Z7dS )LÚ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, ...]r~   r   ÚNonec                 C  s"   || _ || _|| _|| _d | _d S r2   )ÚenvÚengineÚparserÚ	preparserÚassigner©rs   r±   r²   r³   r´   r"   r"   r&   Ú__init__ˆ  s
   
zBaseExprVisitor.__init__c              
   K  sŒ   t |tƒr1|  |¡}z
t t |¡¡}W n ty0 } ztdd„ | ¡ D ƒƒr*d|_	|‚d }~ww dt
|ƒj› �}t| |ƒ}||fi |¤ŽS )Nc                 s  s   � | ]}t |ƒV  qd S r2   r   rA   r"   r"   r&   rE   •  rF   z(BaseExprVisitor.visit.<locals>.<genexpr>z4Python keyword not valid identifier in numexpr queryr}   )rK   r@   r´   rR   Úfix_missing_locationsÚparseÚSyntaxErrorÚanyÚsplitÚmsgrP   rX   rV   )rs   rU   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Â   )rs   rU   r4   Úexprr"   r"   r&   Úvisit_Module�  s   
zBaseExprVisitor.visit_Modulec                 K  s   | j |jfi |¤ŽS r2   ©rÂ   rL   ©rs   rU   r4   r"   r"   r&   Ú
visit_Expr£  s   zBaseExprVisitor.visit_Exprc                 C  sÂ   |j }t|ƒ}t|ƒrVt|ƒrV|| jv rVtt||fƒ\}}tt||fƒ\}}	|s.|s.|s.|	r4| j| ƒ }|	rE| j |j	g¡}
|  
|
| j¡}|rV| j |j	g¡}
|  
|
| j¡}|  |¡}||||fS r2   )r�   rP   r   Úrewrite_mapÚmapÚ_is_listÚ_is_strr±   Úadd_tmprL   r˜   rÂ   )rs   rU   ÚleftÚrightÚop_instanceÚop_typeÚ	left_listÚ
right_listÚleft_strÚ	right_strrW   r�   r"   r"   r&   Ú_rewrite_membership_op¦  s   
z&BaseExprVisitor._rewrite_membership_opNc                 C  sR   |d u r| j |jdd�}|d u r| j |jdd�}|  |||¡\}}}}||||fS )NrÎ   )ÚsiderÏ   )rÂ   rÎ   rÏ   rÖ   )rs   rU   rÎ   rÏ   r�   r…   r"   r"   r&   Ú_maybe_transform_eq_neÁ  s   z&BaseExprVisitor._maybe_transform_eq_nec                 C  s˜   t  t j¡}|jr't|dƒr'|js'|j|kr'| j t  |j¡¡}|  	|| j¡}|jrHt|dƒrH|jsH|j|krH| j t  |j¡¡}|  	|| j¡}||fS )NrL   )
ÚnpÚdtypeÚfloat32Ú	is_scalarÚhasattrÚreturn_typer±   rÍ   rL   r˜   )rs   rÎ   rÏ   Úf32rW   r"   r"   r&   Ú_maybe_downcast_constantsÉ  s(   ÿþý
ÿþý
z)BaseExprVisitor._maybe_downcast_constantsc                 C  s   |  | j| j| j| j|¡S r2   )Úevaluater±   r²   r³   r˜   )rs   ÚbinopÚeval_in_pythonr"   r"   r&   Ú_maybe_evalà  s   ÿzBaseExprVisitor._maybe_eval©Úinznot in©r!   z!=ú<ú>z<=z>=c                 C  sÀ   |||ƒ}|j rtd|j› d|j› d|j› d�ƒ‚| jdkr6|jtv r)t|ddƒs/t|ddƒr6|  || j¡S |j|v rA|  ||¡S | jdkr^t|dd ƒt	ksVt|dd ƒt	kr^|  ||| ¡S |S )	Nz unsupported operand type(s) for z: 'z' and 'rq   ÚpytablesÚis_datetimeFrÞ   )
Úhas_invalid_return_typeÚ	TypeErrorr�   rP   r²   r   rV   rä   Ú
binary_opsÚobject)rs   r�   r…   ÚlhsÚrhsrã   Úmaybe_eval_in_pythonÚresr"   r"   r&   Ú_maybe_evaluate_binopë  s.   
	
ÿÿÿ


ÿ
þ

z%BaseExprVisitor._maybe_evaluate_binopc                 K  s2   |   |¡\}}}}|  ||¡\}}|  ||||¡S r2   )rØ   rà   rô   )rs   rU   r4   r�   r…   rÎ   rÏ   r"   r"   r&   Úvisit_BinOp  s   zBaseExprVisitor.visit_BinOpc                 K  s    |   |j¡}|   |j¡}||ƒS r2   )rÂ   r�   Úoperand)rs   rU   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  ó   |   |j| j¡S r2   ©r—   rL   r±   rÇ   r"   r"   r&   Úvisit_NameConstant   ru   z"BaseExprVisitor.visit_NameConstantc                 K  rú   r2   rû   rÇ   r"   r"   r&   Ú	visit_Num$  ru   zBaseExprVisitor.visit_Numc                 K  rú   r2   rû   rÇ   r"   r"   r&   Úvisit_Constant'  ru   zBaseExprVisitor.visit_Constantc                 K  s   | j  |j¡}|  || j ¡S r2   )r±   rÍ   Úsr˜   ©rs   rU   r4   rW   r"   r"   r&   Ú	visit_Str+  s   zBaseExprVisitor.visit_Strc                   s*   ˆ j  ‡ fdd„|jD ƒ¡}ˆ  |ˆ j ¡S )Nc                   ó   g | ]
}ˆ   |¡ˆ jƒ‘qS r"   ©rÂ   r±   )rB   r¿   ©rs   r"   r&   Ú
<listcomp>0  ó    z.BaseExprVisitor.visit_List.<locals>.<listcomp>)r±   rÍ   Úeltsr˜   r   r"   r  r&   Ú
visit_List/  s   zBaseExprVisitor.visit_Listc                 K  s   |   |j¡S )zdf.index[4]rÆ   rÇ   r"   r"   r&   Úvisit_Index5  s   zBaseExprVisitor.visit_Indexc           
   	   K  s–   ddl m} |  |j¡}|  |j¡}||| j| j| jd�}z|j| }W n ty<   ||| j| j| jd�}|| }Y nw | j 	|¡}	| j
|	| jd�S )Nr   )Úeval)Ú
local_dictr²   r³   )r±   )Úpandasr
  rÂ   rL   Úslicer±   r²   r³   ÚAttributeErrorrÍ   r˜   )
rs   rU   r4   Úpd_evalrL   ÚslobjÚresultÚvrð   rW   r"   r"   r&   Úvisit_Subscript9  s    ÿÿûzBaseExprVisitor.visit_Subscriptr  c                 K  sZ   |j }|dur|  |¡j}|j}|dur|  |¡j}|j}|dur'|  |¡j}t|||ƒS )zdf.index[slice(4,6)]N)ÚlowerrÂ   rL   ÚupperÚstepr  )rs   rU   r4   r  r  r  r"   r"   r&   Úvisit_SliceM  s   zBaseExprVisitor.visit_Slicec                 K  s´   t |jƒdkrtdƒ‚t|jd tjƒstdƒ‚| jjdu r"tdƒ‚z| j	|jd fi |¤Ž}W n t
y?   |jd j}Y nw t|d|ƒ| _| jdu rPt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 objectrW   z@left hand side of an assignment must be a single resolvable name)r<   Útargetsrº   rK   rR   ÚNamer±   ÚtargetÚ
ValueErrorrÂ   r
   rø   rV   rµ   rL   )rs   rU   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 ‚ w tdt|ƒj› �ƒ‚)NzInvalid Attribute context )ÚattrrL   ÚctxrK   rR   ÚLoadrÂ   rV   r±   rÍ   r˜   r  r  rø   r  rP   rX   )	rs   rU   r4   r  rL   r  Úresolvedr  rW   r"   r"   r&   Úvisit_Attributey  s   
üzBaseExprVisitor.visit_Attributec                   sp  t |jtjƒr|jjdkrˆ  |j¡}n.t |jtjƒstdƒ‚zˆ  |j¡}W n t	yA   zt
|jjƒ}W n ty>   ‚ w Y nw |d u rOtd|jj› �ƒ‚t|dƒrW|j}t |t
ƒrv‡ fdd„|jD ƒ}|jrrtd|j› d�ƒ‚||Ž S ‡ fd	d„|jD ƒ}|jD ]!}t |tjƒs•td
|jj› d�ƒ‚|jr¤ˆ  |j¡ˆ jƒ||j< qƒˆ j ||i |¤Ž¡}ˆ j|ˆ jd�S )NÚ__call__z"Only named functions are supportedzInvalid function call rL   c                   s   g | ]}ˆ   |¡‘qS r"   )rÂ   ©rB   Úargr  r"   r&   r  ¦  s    z.BaseExprVisitor.visit_Call.<locals>.<listcomp>z
Function "z$" does not support keyword argumentsc                   r  r"   r  r#  r  r"   r&   r  °  r  z keyword error in function call 'rq   )rW   r±   )rK   ÚfuncrR   Ú	Attributer  r!  r  rí   rÂ   r
   r   rø   r  rÝ   rL   r3   ÚkeywordsrW   Úkeywordr$  r±   rÍ   r˜   )rs   rU   r×   r4   ró   Únew_argsÚkeyrW   r"   r  r&   Ú
visit_Call�  sP   þÿýÿ

ÿ
ÿÿ€zBaseExprVisitor.visit_Callc                 C  s   |S r2   r"   )rs   r�   r"   r"   r&   Útranslate_InÀ  s   zBaseExprVisitor.translate_Inc              	   K  sª   |j }|j}t|ƒdkr#|  |d ¡}tj||j|d d�}|  |¡S |j}g }t||ƒD ]\}}	|  tj	|	g||  |¡gd�¡}
|	}| 
|
¡ q-|  tjt ¡ |d�¡S )Nr;   r   )r�   rÎ   rÏ   )ÚcomparatorsrÎ   rŽ   )r�   Úvalues)rŽ   r-  r<   r,  rR   r   rÎ   rÂ   ÚzipÚCompareÚappendÚBoolOpr£   )rs   rU   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   )rK   r   r   rÂ   )rs   Úbopr"   r"   r&   Ú_try_visit_binopØ  s   
z BaseExprVisitor._try_visit_binopc                   s   ‡ ‡fdd„}ˆ j }t||ƒS )Nc                   s<   ˆ  | ¡}ˆ  |¡}ˆ ˆ ||¡\}}}}ˆ |ˆ j||¡S r2   )r8  rØ   rô   r�   )rC   Úyrð   rñ   r�   r…   ©rU   rs   r"   r&   rÁ   Þ  s   

z-BaseExprVisitor.visit_BoolOp.<locals>.visitor)r.  r   )rs   rU   r4   rÁ   Úoperandsr"   r:  r&   Úvisit_BoolOpÝ  s   
zBaseExprVisitor.visit_BoolOp©r   r°   )NN)rå   rç   )r   r   )r   r  r2   )8rX   Ú
__module__Ú__qualname__Ú__doc__r   r—   Ú__annotations__r   r˜   r   r   r   rî   Úbinary_op_nodesÚdictr/  Úbinary_op_nodes_mapr   Ú	unary_opsÚunary_op_nodesÚunary_op_nodes_maprR   r�   rŸ   rž   r    rÉ   rJ   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,  r6  r8  r<  r"   r"   r"   r&   r–   Q  s\   
 ü

ù'








3r–   )ÚDictr2  rŸ   r    )r2  r&  rŸ   r    ÚTuplec                      s2   e Zd Zeeeeeeƒd�f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__r=  )rX   r>  r?  r   rJ   r>   r1   r/   r   r·   Ú__classcell__r"   r"   rN  r&   rK  í  s    

þûrK  r¯   c                      s(   e Zd Zddd„fd	‡ fdd„Z‡  ZS )
ÚPythonExprVisitorNc                 C  s   | S r2   r"   rI   r"   r"   r&   r8     s    zPythonExprVisitor.<lambda>r   r°   c                   s   t ƒ j||||d� d S )N)r´   rL  r¶   rN  r"   r&   r·     s   zPythonExprVisitor.__init__r2   r=  )rX   r>  r?  r·   rP  r"   r"   rN  r&   rQ  ÿ  s    ÿrQ  c                   @  sz   e Zd ZU dZded< ded< ded< 					
dddd„Zedd„ ƒZdd„ Zd dd„Z	d!dd„Z
dd„ Zedd„ ƒZd	S )"rc   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   úScope | NoneÚlevelÚintr   r°   c                 C  sL   || _ |pt|d d�| _|| _|| _t| | j| j| jƒ| _|  ¡ | _d S )Nr;   )rT  )	rÄ   r   r±   r²   r³   ÚPARSERSÚ_visitorr¹   Úterms)rs   rÄ   r²   r³   r±   rT  r"   r"   r&   r·     s   zExpr.__init__c                 C  s   t | jdd ƒS )Nrµ   )rV   rW  r  r"   r"   r&   rµ   '  s   zExpr.assignerc                 C  s   |   | j¡S r2   )rX  r±   r  r"   r"   r&   r"  +  ó   zExpr.__call__c                 C  s   t  | j¡S r2   )r   Úpprint_thingrX  r  r"   r"   r&   Ú__repr__.  rY  zExpr.__repr__c                 C  s
   t | jƒS r2   )r<   rÄ   r  r"   r"   r&   Ú__len__1  s   
zExpr.__len__c                 C  s   | j  | j¡S )z&
        Parse an expression.
        )rW  rÂ   rÄ   r  r"   r"   r&   r¹   4  r:   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  r_   r2   )rW   )rB   Útermr"   r"   r&   rE   A  r`   zExpr.names.<locals>.<genexpr>)r   rX  r[   rW   ÚcomÚflattenr  r"   r"   r&   Únames:  s   
z
Expr.names)rR  r  Nr   )
r²   r@   r³   r@   r±   rS  rT  rU  r   r°   )r   r@   )r   rU  )rX   r>  r?  r@  rA  r·   Úpropertyrµ   r"  r[  r\  r¹   r`  r"   r"   r"   r&   rc     s$   
 ú


rc   )Úpythonr  )r   r   r   r   )r?   r@   r   r@   )rn   r@   r   ro   )rx   ry   r   rz   )ir@  Ú
__future__r   rR   Ú	functoolsr   r   r(  r   r,   Útypingr   r   r	   ÚnumpyrÙ   Úpandas.errorsr
   Úpandas.core.commonÚcoreÚcommonr^  Úpandas.core.computation.opsr   r   r   r   r   r   r   r   r   r   r   r   r   r   Úpandas.core.computation.parsingr   r   Úpandas.core.computation.scoper   Úpandas.io.formatsr   r'   r/   r1   r9   r>   rJ   rO   ÚlistrË   r@   rÌ   r[   ÚdirÚ
_all_nodesr^   Ú_all_node_namesÚmodÚ
_mod_nodesÚstmtÚ_stmt_nodesrÄ   Ú_expr_nodesÚexpr_contextÚ_expr_context_nodesÚboolopÚ_boolop_nodesÚoperatorÚ_operator_nodesÚunaryopÚ_unary_op_nodesÚcmpopÚ_cmp_op_nodesÚcomprehensionÚ_comprehension_nodesÚexcepthandlerÚ_handler_nodesÚ	argumentsÚ_arguments_nodesÚ_keyword_nodesÚaliasÚ_alias_nodesÚ_hacked_nodesÚ_unsupported_expr_nodesÚ_unsupported_nodesÚ_base_supported_nodesÚintersectionÚ_msgrv   rw   rƒ   r‡   Ú_op_classesr•   ÚNodeVisitorr–   Ú_python_not_supportedÚ_numexpr_supported_callsrK  rQ  rc   rV  r"   r"   r"   r&   Ú<module>   sº    @



ÿþ"þ












ÿÿþýüûúù÷



   ÿÿ=