
    id                       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c 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- erddl.m/Z/ d.dZ0d.dZ1d.dZ2d Z3d Z4 e4e2e1e0e(      f	 	 	 d/dZ5d Z6 e6e7      Z8 e6e9      Z: e;d d  e<e      D        D              Z=e=fdZ> e;d e=D              Z? e>ej                        ZA e>ej                        ZC e>ej                        ZE e>ej                        ZG e>ej                        ZI e>ej                        ZK e>ej                        ZM e>ej                        ZO e>ej                        ZQ e>ej                        ZS e>ej                        ZU e>ej                        ZV e>ej                        ZX e;g d      ZY e;g d      ZZeCeAz  eSz  eUz  eVz  eXz  eGz  eZz  eYz
  Z[e?e[z
  eYz  Z\e[e\z  Z]de] Z^e]rJ e^       d0dZ_ ed      Z`d1dZad Zbe e%d Zcd! Zd eae[       edec       G d" d#ej                                      Zf e;g d$      Zg e;eez         Zh eae[egz  eI e;g d%      z  z
         G d& d'ef             Zi eae[egz   e;d(g      z         G d) d*ef             Zj G d+ d,      Zkejeid-Zly)2z
:func:`~pandas.eval` parsers.
    )annotationsN)partialreduce	iskeyword)TYPE_CHECKING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)printing)Callablec                $    | \  }}||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
    === toktoknumtokvals      Y/app/cer_product_mecsu/.venv/lib/python3.12/site-packages/pandas/core/computation/expr.py_rewrite_assignr)   7   s&     NFF6S=444f44    c                    | \  }}|t         j                  k(  r2|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$   s      r(   _replace_booleansr3   J   sY     NFFS===%''s]==$&&v~6>r*   c                p    | \  }}|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.
    @)r0   r1   r   r$   s      r(   _replace_localsr6   c   s8    ( NFF3{{I%%6>r*   c                      fdS )z
    Compose 2 callables.
    c                        | i |      S Nr#   )argskwargsfgs     r(   <lambda>z_compose2.<locals>.<lambda>   s    1Q%7%7#8 r*   r#   )r<   r=   s   ``r(   	_compose2r?   }   s     98r*   c                 L    t        |       dkD  sJ d       t        t        |       S )z&
    Compose 2 or more callables.
       z.At least 2 callables must be passed to compose)lenr   r?   )funcss    r(   _composerD      s'     u:>KKK>)U##r*   c                v    t              sJ d       t        j                  f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  .   K   | ]  } |        y wr9   r#   ).0xr<   s     r(   	<genexpr>z_preparse.<locals>.<genexpr>   s       	
!s   )callabler0   
untokenizer   sourcer<   s    `r(   	_preparserN      s<    < A;,,,;  (  r*   c                      fdS )zO
    Factory for a type checking function of type ``t`` or tuple of types.
    c                0    t        | j                        S r9   )
isinstancevalue)rH   ts    r(   r>   z_is_type.<locals>.<lambda>   s    Z+ r*   r#   )rS   s   `r(   _is_typerT      s     ,+r*   c              #  t   K   | ]0  }t        |t              rt        |t        j                        r| 2 y wr9   )rQ   type
issubclassastAST)rG   nodes     r(   rI   rI      s/      $*T377"; 	s   68c              #  <   K   | ]  }t        t        |        y wr9   )getattrrX   )rG   names     r(   rI   rI      s     9d#9s   c                0      fd|D        }t        |      S )zE
    Filter out AST nodes that are subclasses of ``superclass``.
    c              3  P   K   | ]  }t        |      s|j                    y wr9   )rW   __name__)rG   rZ   
superclasss     r(   rI   z _filter_nodes.<locals>.<genexpr>   s     VDD*9U$--Vs   &&)	frozenset)ra   	all_nodes
node_namess   `  r(   _filter_nodesre      s     WIVJZ  r*   c              #  4   K   | ]  }|j                     y wr9   )r`   rG   rH   s     r(   rI   rI      s     ;1AJJ;   )AssignModuleExpr)YieldGeneratorExpIfExpDictCompSetCompReprLambdaSetrY   IsIsNotz$cannot both support and not support c                      fd}|S )zV
    Return a function that raises a NotImplementedError with a passed node name.
    c                "    t        d d      )N'z' nodes are not implemented)NotImplementedError)selfr:   r;   	node_names      r(   r<   z _node_not_implemented.<locals>.f
  s    !Ai[0K"LMMr*   r#   )r{   r<   s   ` r(   _node_not_implementedr|     s    
N Hr*   _Tc                     d fd}|S )z
    Decorator to disallow certain nodes from parsing. Raises a
    NotImplementedError instead.

    Returns
    -------
    callable
    c                    d| _         D ]5  }t        |      }d| }| xj                   |fz  c_         t        | ||       7 | S )Nr#   visit_)unsupported_nodesr|   setattr)clsrZ   
new_methodr]   nodess       r(   
disallowedzdisallow.<locals>.disallowed   sU     " 	+D.t4JD6?D!!dW,!Cz*	+ 
r*   )r   type[_T]returnr   r#   )r   r   s   ` r(   disallowr     s    	 r*   c                      fd}|S )zw
    Return a function to create an op class with its symbol already passed.

    Returns
    -------
    callable
    c                $    t        g|i |S )z
        Return a partial function with an Op subclass with an operator already passed.

        Returns
        -------
        callable
        )r   )rz   rZ   r:   r;   op_class	op_symbols       r(   r<   z_op_maker.<locals>.f7  s     x<T<V<<r*   r#   )r   r   r<   s   `` r(   	_op_makerr   .  s    = Hr*   )binaryunaryc                      fd}|S )z9
    Decorator to add default implementation of ops.
    c                    j                         D ]N  \  }}t        | | d      }t        | | d      }|D ]&  }||   }|t        ||      }t        | d| |       ( P | S )N_ops_op_nodes_mapr   )itemsr\   r   r   )	r   op_attr_namer   opsops_mapopop_nodemade_op
op_classess	           r(   r<   zadd_ops.<locals>.fL  s    &0&6&6&8 	>"L(#,t45Ccl^=#ABG >!"+&'"5GC6'!3W=	>	> 
r*   r#   )r   r<   s   ` r(   add_opsr   G  s    
	 Hr*   c                     e Zd ZU dZeZded<   eZded<   e	e
z   ez   ZdZ e eeed            ZeZdZ e eeed            Zej,                  ej.                  ej0                  ej2                  ej.                  ej.                  ej2                  ej2                  iZd	ed
<   efd'dZd Zd Zd Zd Z d(dZ!d Z"d Z#	 	 d)dZ$d Z%d Z&d*dZ'd*dZ(d*dZ)d*dZ*d*dZ+d*dZ,e,Z-d Z.d*dZ/d+dZ0d  Z1d! Z2d,d"Z3d# Z4d$ Z5d% Z6d& Z7y)-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ModTstrict)UAddUSubInvertNotztuple[str, ...]r   c                J    || _         || _        || _        || _        d | _        y r9   )envengineparser	preparserassigner)rz   r   r   r   r   s        r(   __init__zBaseExprVisitor.__init__  s%    "r*   c                d   t        |t              r:| j                  |      }	 t        j                  t        j
                  |            }dt        |      j                   }t        | |      } ||fi |S # t        $ r.}t        d |j                         D              rd|_	        |d }~ww xY w)Nc              3  2   K   | ]  }t        |        y wr9   r   rg   s     r(   rI   z(BaseExprVisitor.visit.<locals>.<genexpr>  s     ;y|;s   z4Python keyword not valid identifier in numexpr queryr   )rQ   strr   rX   fix_missing_locationsparseSyntaxErroranysplitmsgrV   r`   r\   )rz   rZ   r;   cleanemethodvisitors          r(   visitzBaseExprVisitor.visit  s    dC NN4(E0051AB $t*--./$'t&v&&  ;U[[];;RAEs   (A8 8	B/)B**B/c                    t        |j                        dk7  rt        d      |j                  d   } | j                  |fi |S )NrA   z#only a single expression is allowedr   )rB   bodyr   r   )rz   rZ   r;   exprs       r(   visit_ModulezBaseExprVisitor.visit_Module  sA    tyy>QCDDyy|tzz$)&))r*   c                <     | j                   |j                  fi |S r9   r   rR   rz   rZ   r;   s      r(   
visit_ExprzBaseExprVisitor.visit_Expr  s    tzz$**///r*   c                B   |j                   }t        |      }t        |      rt        |      r|| j                  v rt	        t
        ||f      \  }}t	        t        ||f      \  }}	|s|s|s|	r | j                  |          }|	rB| j                  j                  |j                  g      }
| j                  |
| j                        }|rB| j                  j                  |j                  g      }
| j                  |
| j                        }| j                  |      }||||fS r9   )r   rV   r   rewrite_mapmap_is_list_is_strr   add_tmprR   r   r   )rz   rZ   leftrightop_instanceop_type	left_list
right_listleft_str	right_strr]   r   s               r(   _rewrite_membership_opz&BaseExprVisitor._rewrite_membership_op  s    gg{# 4=WU^4;K;K0K$'4-$@!Iz"%ge}"=Hi J(i7d..w79 xx''6tTXX6xx''5~~dDHH5ZZ$;e++r*   Nc                    || j                  |j                  d      }|| j                  |j                  d      }| j                  |||      \  }}}}||||fS )Nr   )sider   )r   r   r   r   )rz   rZ   r   r   r   r   s         r(   _maybe_transform_eq_nez&BaseExprVisitor._maybe_transform_eq_ne  sd    <::diif:5D=JJtzzJ8E$($?$?dE$R!HdE8T5((r*   c                l   t        j                  t         j                        }|j                  r{t	        |d      ro|j                  sc|j
                  |k(  rT| j                  j                  t        j                  |j                              }| j                  || j                        }|j                  r{t	        |d      ro|j                  sc|j
                  |k(  rT| j                  j                  t        j                  |j                              }| j                  || j                        }||fS )NrR   )
npdtypefloat32	is_scalarhasattrreturn_typer   r   rR   r   )rz   r   r   f32r]   s        r(   _maybe_downcast_constantsz)BaseExprVisitor._maybe_downcast_constants  s    hhrzz"NNg&OO!!S( 88##BJJtzz$:;D>>$1DOOw'NN  C' 88##BJJu{{$;<DNN42EU{r*   c                |    |j                  | j                  | j                  | j                  | j                  |      S r9   )evaluater   r   r   r   )rz   binopeval_in_pythons      r(   _maybe_evalzBaseExprVisitor._maybe_eval  s0     ~~HHdkk4;;
 	
r*   c           	     t    |||      }|j                   r3t        d|j                   d|j                   d|j                   d      | j                  dk7  rH|j                  t
        v rt        |dd      st        |dd      r| j                  || j                        S |j                  |v r| j                  ||      S | j                  dk7  rit        |dd       t        k(  s@t        t        |dd             s*t        |dd       t        k(  st        t        |dd             r| j                  |||z         S |S )	Nz unsupported operand type(s) for z: 'z' and 'rx   pytablesis_datetimeFr   )has_invalid_return_type	TypeErrorr   rV   r   r   r\   r   
binary_opsobjectr   )rz   r   r   lhsrhsr   maybe_eval_in_pythonress           r(   _maybe_evaluate_binopz%BaseExprVisitor._maybe_evaluate_binop  s(    cl&&2366( ;HH:WSXXJa1 
 ;;*$VV|#]E(JsM51 ##C9966^###C88[[J&]D1V;"73t#DE3t4>"73t#DE ''^>R-RSS
r*   c                    | j                  |      \  }}}}| j                  ||      \  }}| j                  ||||      S r9   )r   r   r  )rz   rZ   r;   r   r   r   r   s          r(   visit_BinOpzBaseExprVisitor.visit_BinOp  sH    $($?$?$E!HdE44T5Ae))"heDDr*   c                ~    | j                  |j                        }| j                  |j                        } ||      S r9   )r   r   operand)rz   rZ   r;   r   r  s        r(   visit_UnaryOpzBaseExprVisitor.visit_UnaryOp!  s0    ZZ **T\\*'{r*   c                R     | j                   |j                  | j                  fi |S r9   )r   idr   r   s      r(   
visit_NamezBaseExprVisitor.visit_Name&  s"    t~~dggtxx:6::r*   c                N    | j                  |j                  | j                        S r9   r   rR   r   r   s      r(   visit_NameConstantz"BaseExprVisitor.visit_NameConstant*      tzz48844r*   c                N    | j                  |j                  | j                        S r9   r  r   s      r(   	visit_NumzBaseExprVisitor.visit_Num.  r  r*   c                N    | j                  |j                  | j                        S r9   r  r   s      r(   visit_ConstantzBaseExprVisitor.visit_Constant1  r  r*   c                    | j                   j                  |j                        }| j                  || j                         S r9   )r   r   sr   )rz   rZ   r;   r]   s       r(   	visit_StrzBaseExprVisitor.visit_Str5  s/    xx'~~dDHH--r*   c           	         | j                   j                  |j                  D cg c]#  } | j                  |      | j                         % c}      }| j	                  || j                         S c c}w r9   )r   r   eltsr   r   )rz   rZ   r;   r   r]   s        r(   
visit_ListzBaseExprVisitor.visit_List9  sS    xx$)) LQAtxx!8 LM~~dDHH-- !Ms   (A/c                8    | j                  |j                        S )zdf.index[4]r   r   s      r(   visit_IndexzBaseExprVisitor.visit_Index?  s    zz$**%%r*   c                   ddl m} | j                  |j                        }| j                  |j                        } ||| j
                  | j                  | j                        }	 |j                  |   }| j
                  j                  |      }	| j                  |	| j
                        S # t        $ r2  ||| j
                  | j                  | j                        }||   }Y rw xY w)Nr   )eval)
local_dictr   r   )r   )pandasr  r   rR   slicer   r   r   AttributeErrorr   r   )
rz   rZ   r;   pd_evalrR   slobjresultvr   r]   s
             r(   visit_SubscriptzBaseExprVisitor.visit_SubscriptC  s    *

4::&

4::&dhht{{4;;
	F#A xx"~~d~11  	$((4;;t{{C FA	s   (B/ /8C*)C*c                   |j                   }|| j                  |      j                  }|j                  }|| j                  |      j                  }|j                  }|| j                  |      j                  }t        |||      S )zdf.index[slice(4,6)])lowerr   rR   upperstepr   )rz   rZ   r;   r(  r)  r*  s         r(   visit_SlicezBaseExprVisitor.visit_SliceW  sz    

JJu%++E

JJu%++Eyy::d#))DUE4((r*   c                   t        |j                        dk7  rt        d      t        |j                  d   t        j
                        st        d      | j                  j                  t        d      	  | j                  |j                  d   fi |}t        |d|      | _        | j                  t        d       | j                  |j                  fi |S # t        $ r |j                  d   j                  }Y jw xY w)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

        rA   z#can only assign a single expressionr   z5left hand side of an assignment must be a single namez%cannot assign without a target objectr]   z@left hand side of an assignment must be a single resolvable name)rB   targetsr   rQ   rX   Namer   target
ValueErrorr   r   r
  r\   r   rR   )rz   rZ   r;   r   s       r(   visit_AssignzBaseExprVisitor.visit_Assigne  s     t||!CDD$,,q/3884UVV88??"DEE	*!tzz$,,q/<V<H  &(;== R  tzz$**/// & 	*||A))H	*s   8 C "DDc                6   |j                   }|j                  }|j                  }t        |t        j
                        r| j                  |      }t        |d      r|j                  }n || j                        }	 t        ||      }| j                  j                  |      }	| j                  |	| j                        S t        dt!        |      j"                         # t        $ r/ t        |t        j                        r|j                  |k(  r|cY S  w xY w)NrR   zInvalid Attribute context )attrrR   ctxrQ   rX   Loadr   r   r   r\   r   r   r!  r.  r
  r0  rV   r`   )
rz   rZ   r;   r3  rR   r4  visited_valueresolvedr%  r]   s
             r(   visit_AttributezBaseExprVisitor.visit_Attribute  s    yy

hhc388$ JJu-M}g.(..(2Hd+xx''*~~dDHH55 5d3i6H6H5IJKK " eSXX.588t3C#O	s   <AC   4DDc                *   t        |j                  t        j                        r5|j                  j                  dk7  r| j                  |j                        }nKt        |j                  t        j                        st        d      	 | j                  |j                        }|"t        d|j                  j                         t        |d      r|j                  }t        |t              rR|j                  D cg c]  }| j                  |       }}|j                   rt        d|j"                   d       || S |j                  D cg c]#  } | j                  |      | j$                        % }}|j                   D ]  }t        |t        j&                        s#t        d|j                  j                   d      |j(                  sM | j                  |j                        | j$                        ||j(                  <    | j$                  j+                   ||i |      }| j-                  || j$                  	      S # t        $ r3 	 t        |j                  j                        }n# t        $ r  w xY wY w xY wc c}w c c}w )
N__call__z"Only named functions are supportedzInvalid function call rR   z
Function "z$" does not support keyword argumentsz keyword error in function call 'rx   )r]   r   )rQ   funcrX   	Attributer3  r8  r.  r   r   r   r   r
  r0  r   rR   r:   keywordsr]   r   keywordargr   r   )	rz   rZ   r   r;   r  r?  new_argskeyr]   s	            r(   
visit_CallzBaseExprVisitor.visit_Call  s#   dii/DIINNj4P&&tyy1CDIIsxx0@AAjj+ ;(7  3 ))Cc8$3799=C

3=H=}} 
*NO  >! >BYYGc

31GHG}} 	F!#s{{3 %:499<<.J  77&;djj&;DHH&EF377O	F 88##C$<V$<=D>>t>::S * "499<<0C!  " > Hs6   
I ?J(J	JI65J6JJJc                    |S r9   r#   )rz   r   s     r(   translate_InzBaseExprVisitor.translate_In  s    	r*   c           
     0   |j                   }|j                  }t        |      dk(  rJ| j                  |d         }t	        j
                  ||j                  |d         }| j                  |      S |j                  }g }t        ||d      D ]P  \  }}	| j                  t	        j                  |	g|| j                  |      g            }
|	}|j                  |
       R | j                  t	        j                  t	        j                         |            S )NrA   r   )r   r   r   Tr   )comparatorsr   r   )r   values)r   rF  rB   rD  rX   r   r   r   zipCompareappendBoolOpr   )rz   rZ   r;   r   compsr   r   r   rG  compnew_nodes              r(   visit_ComparezBaseExprVisitor.visit_Compare  s    hh   u:?""3q6*BII$))58DE::e$$ yyCt4 	$HBzzT@Q@QRT@U?VWH DMM(#	$ zz#**	&ABBr*   c                T    t        |t        t        f      r|S | j                  |      S r9   )rQ   r   r   r   )rz   bops     r(   _try_visit_binopz BaseExprVisitor._try_visit_binop  s#    cB:&Jzz#r*   c                B      fd}j                   }t        ||      S )Nc                    j                  |       }j                  |      }j                  ||      \  }}}}j                  |j                  ||      S r9   )rR  r   r  r   )rH   yr   r   r   r   rZ   rz   s         r(   r   z-BaseExprVisitor.visit_BoolOp.<locals>.visitor  s[    ''*C''*C%)%@%@sC%P"B#s--b$''3DDr*   )rG  r   )rz   rZ   r;   r   operandss   ``   r(   visit_BoolOpzBaseExprVisitor.visit_BoolOp  s!    	E ;;gx((r*   r   None)NN))inznot in)r"   z!=<>z<=z>=)r   r   )r   r   r9   )8r`   
__module____qualname____doc__r   r   __annotations__r   r   r   r   r   r   binary_op_nodesdictrH  binary_op_nodes_mapr   	unary_opsunary_op_nodesunary_op_nodes_maprX   r   r   r   r   r   rN   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r  r  r  visit_Tupler  r&  r+  r1  r8  rB  rD  rO  rR  rW  r#   r*   r(   r   r   Z  sL   
 (0J$/&*I#*->JO* s:tLMI4Nc)^DIJ 			399		399	K '&6? '*0,6).	
" (?&PE

;555.. K&2()0<L01;fC*
	)r*   r   )DictrK  r   r   )rK  r<  r   r   Tuplec                  F     e Zd Z ee eeee            f	 d fdZ	 xZ
S )PandasExprVisitor)r<   c                *    t         |   ||||       y r9   superr   rz   r   r   r   r   	__class__s        r(   r   zPandasExprVisitor.__init__   s     	ffi8r*   rX  )r`   r]  r^  r   rN   rD   r6   r3   r   r   __classcell__rp  s   @r(   rk  rk    s2     (9;UV

9 

9 
9r*   rk  r   c                  *     e Zd Zddf	 d fdZ xZS )PythonExprVisitorc                    | S r9   r#   rL   s     r(   r>   zPythonExprVisitor.<lambda>  s    F r*   c                ,    t         |   ||||       y )N)r   rm  ro  s        r(   r   zPythonExprVisitor.__init__  s     	ff	Br*   r9   rX  )r`   r]  r^  r   rq  rr  s   @r(   rt  rt    s     .KC	C Cr*   rt  c                      e Zd ZU dZded<   ded<   ded<   	 	 	 	 d	 	 	 	 	 	 	 	 	 ddZed	        Zd
 ZddZ	ddZ
d Zed        Zy)rk   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   Nc                    || _         |xs t        |dz         | _        || _        || _        t        |   | j                  | j                  | j                        | _        | j                         | _        y )NrA   )level)	r   r   r   r   r   PARSERS_visitorr   terms)rz   r   r   r   r   ry  s         r(   r   zExpr.__init__&  s[     	0%eai0$++t{{KZZ\
r*   c                0    t        | j                  dd       S )Nr   )r\   r{  rz   s    r(   r   zExpr.assigner5  s    t}}j$77r*   c                8    | j                  | j                        S r9   )r|  r   r~  s    r(   r:  zExpr.__call__9  s    zz$((##r*   c                @    t        j                  | j                        S r9   )r   pprint_thingr|  r~  s    r(   __repr__zExpr.__repr__<  s    $$TZZ00r*   c                ,    t        | j                        S r9   )rB   r   r~  s    r(   __len__zExpr.__len__?  s    499~r*   c                L    | j                   j                  | j                        S )z&
        Parse an expression.
        )r{  r   r   r~  s    r(   r   z
Expr.parseB  s     }}""499--r*   c                    t        | j                        r t        | j                  j                  g      S t        d t	        j
                  | j                        D              S )z1
        Get the names in an expression.
        c              3  4   K   | ]  }|j                     y wr9   )r]   )rG   terms     r(   rI   zExpr.names.<locals>.<genexpr>O  s     GtGrh   )r   r|  rb   r]   comflattenr~  s    r(   namesz
Expr.namesH  sD    
 4::djjoo.//Gs{{4::/FGGGr*   )numexprr  Nr   )
r   r   r   r   r   zScope | Nonery  intr   rY  )r   r   )r   r  )r`   r]  r^  r_  r`  r   propertyr   r:  r  r  r   r  r#   r*   r(   rk   rk     s    
 
JKK
   " " 	"
 " " 
" 8 8$1. H Hr*   rk   )pythonr  )r%   tuple[int, str]r   r  )rM   r   r   r   )r{   r   r   zCallable[..., None])r   zset[str]r   zCallable[[type[_T]], type[_T]])mr_  
__future__r   rX   	functoolsr   r   r>  r   r0   typingr   r	   r
   numpyr   pandas.errorsr   pandas.core.dtypes.commonr   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   collections.abcr   r)   r3   r6   r?   rD   rN   rT   listr   r   r   rb   dir
_all_nodesre   _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_msgr|   r}   r   r   _op_classesr   NodeVisitorr   _python_not_supported_numexpr_supported_callsrk  rt  rk   rz  r#   r*   r(   <module>r     su   # 
     0 5         0 &(5&249$ *O=W""
 	"J, D>
3-  9C9 
 )3 ! ;
;;377#
CHH%CHH%#C$4$45 cjj)-,cii($S%6%67 s001 / s{{+SYY' 67 $ $   	
    	  )+==N !$99	-l^<   T]0, 1& 

X)coo X)  X)v ""CD $Z'%9:  
//y!PQQS9 9	9 

4
4y%7I
IJC C KC:H :Hz '2C
Dr*   