
    gHb                       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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$m%Z% dd	l&m'Z'm(Z( dd
l)m*Z* ddl+m,Z, d,dZ-d,dZ.d,dZ/d Z0d Z1 e1e/e.e-e'      f	 	 	 d-dZ2d Z3 e3e4      Z5 e3e6      Z7 e8d d  e9e      D        D              Z:e:fdZ; e8d e:D              Z< e;ejz                        Z> e;ej~                        Z@ e;ej                        ZB e;ej                        ZD e;ej                        ZF e;ej                        ZH e;ej                        ZJ e;ej                        ZL e;ej                        ZN e;ej                        ZP e;ej                        ZR e;ej                        ZS e;ej                        ZU e8g d      ZV e8g d      ZWe@e>z  ePz  eRz  eSz  eUz  eDz  eWz  eVz
  ZXe<eXz
  eVz  ZYeXeYz  ZZdeZ Z[eZrJ e[       d.dZ\ ed      Z]d/dZ^d Z_ee$dZ`d Za e^eX       eae`       G d  d!ej                                      Zc e8g d"      Zd e8eez         Ze e^eXedz  eF e8g d#      z  z
         G d$ d%ec             Zf e^eXedz   e8d&g      z         G d' d(ec             Zg G d) d*      Zhegefd+Ziy)0z
: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DivFuncNodeOpTermUnaryOpis_term)clean_backtick_quoted_tokstokenize_string)Scope)printingc                $    | \  }}||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/var/www/dash_apps/app1/venv/lib/python3.12/site-packages/pandas/core/computation/expr.py_rewrite_assignr(   2   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_booleansr2   E   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.
    @)r/   r0   r   r#   s      r'   _replace_localsr5   ^   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>   x   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'   _composerC      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r8   r"   ).0xr;   s     r'   	<genexpr>z_preparse.<locals>.<genexpr>   s     EqtEs   )callabler/   
untokenizer   sourcer;   s    `r'   	_preparserM      s3    < A;,,,;E_V-DEEEr)   c                      fdS )zO
    Factory for a type checking function of type ``t`` or tuple of types.
    c                0    t        | j                        S r8   )
isinstancevalue)rG   ts    r'   r=   z_is_type.<locals>.<lambda>   s    Z+ r)   r"   )rR   s   `r'   _is_typerS      s     ,+r)   c              #  t   K   | ]0  }t        |t              rt        |t        j                        r| 2 y wr8   )rP   type
issubclassastAST)rF   nodes     r'   rH   rH      s/      $*T377"; 	s   68c              #  <   K   | ]  }t        t        |        y wr8   )getattrrW   )rF   names     r'   rH   rH      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r8   )rV   __name__)rF   rY   
superclasss     r'   rH   z _filter_nodes.<locals>.<genexpr>   s     VDD*9U$--Vs   &&)	frozenset)r`   	all_nodes
node_namess   `  r'   _filter_nodesrd      s     WIVJZ  r)   c              #  4   K   | ]  }|j                     y wr8   )r_   rF   rG   s     r'   rH   rH      s     ;1AJJ;   )AssignModuleExpr)YieldGeneratorExpIfExpDictCompSetCompReprLambdaSetrX   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)selfr9   r:   	node_names      r'   r;   z _node_not_implemented.<locals>.f  s    !Ai[0K"LMMr)   r"   )rz   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)clsrY   
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   )ry   rY   r9   r:   op_class	op_symbols       r'   r;   z_op_maker.<locals>.f/  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>.fD  s    &0&6&6&8 	>"L(#,t45Ccl^=#ABG >!"+&'"5GC6'!3W=	>	> 
r)   r"   )r   r;   s   ` r'   add_opsr   ?  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            ZeZdZ e eee            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 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Z0d*dZ1d Z2d  Z3d+d!Z4d" Z5d# Z6d$ Z7d% Z8y),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MultNPowFloorDivMod)UAddUSubInvertNotztuple[str, ...]r   c                J    || _         || _        || _        || _        d | _        y r8   )envengineparser	preparserassigner)ry   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r8   r   rf   s     r'   rH   z(BaseExprVisitor.visit.<locals>.<genexpr>  s     ;y|;s   z4Python keyword not valid identifier in numexpr queryr   )rP   strr   rW   fix_missing_locationsparseSyntaxErroranysplitmsgrU   r_   r[   )ry   rY   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 )Nr@   z#only a single expression is allowedr   )rA   bodyr   r   )ry   rY   r:   exprs       r'   visit_ModulezBaseExprVisitor.visit_Module  sA    tyy>QCDDyy|tzz$)&))r)   c                <     | j                   |j                  fi |S r8   r   rQ   ry   rY   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 r8   )r   rU   r   rewrite_mapmap_is_list_is_strr   add_tmprQ   r   r   )ry   rY   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   )ry   rY   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 )NrQ   )
npdtypefloat32	is_scalarhasattrreturn_typer   r   rQ   r   )ry   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 r8   )evaluater   r   r   r   )ry   binopeval_in_pythons      r'   _maybe_evalzBaseExprVisitor._maybe_eval  s0     ~~HHdkk4;;
 	
r)   c           	         |||      }|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  r=t        |dd       t        k(  st        |dd       t        k(  r| j                  |||z         S |S )	Nz unsupported operand type(s) for z: 'z' and 'rw   pytablesis_datetimeFr   )
has_invalid_return_type	TypeErrorr   rU   r   r   r[   r   
binary_opsobject)ry   r   r   lhsrhsr   maybe_eval_in_pythonress           r'   _maybe_evaluate_binopz%BaseExprVisitor._maybe_evaluate_binop  s    cl&&2366( ;HH:WSXXJa1 
 ;;*$FFl"]E2sM51 ##C9966^###C88[[J&]D1V;3t4> ''^>R-RSS
r)   c                    | j                  |      \  }}}}| j                  ||      \  }}| j                  ||||      S r8   )r   r   r   )ry   rY   r:   r   r   r   r   s          r'   visit_BinOpzBaseExprVisitor.visit_BinOp  sH    $($?$?$E!HdE44T5Ae))"heDDr)   c                    d S )Nc                    t        | |      S r8   )r   )r   r   s     r'   r=   z+BaseExprVisitor.visit_Div.<locals>.<lambda>  s    C r)   r"   r   s      r'   	visit_DivzBaseExprVisitor.visit_Div  s    --r)   c                ~    | j                  |j                        }| j                  |j                        } ||      S r8   )r   r   operand)ry   rY   r:   r   r  s        r'   visit_UnaryOpzBaseExprVisitor.visit_UnaryOp  s0    ZZ **T\\*'{r)   c                R     | j                   |j                  | j                  fi |S r8   )r   idr   r   s      r'   
visit_NamezBaseExprVisitor.visit_Name   s"    t~~dggtxx:6::r)   c                N    | j                  |j                  | j                        S r8   r   rQ   r   r   s      r'   visit_NameConstantz"BaseExprVisitor.visit_NameConstant$      tzz48844r)   c                N    | j                  |j                  | j                        S r8   r  r   s      r'   	visit_NumzBaseExprVisitor.visit_Num(  r  r)   c                N    | j                  |j                  | j                        S r8   r  r   s      r'   visit_ConstantzBaseExprVisitor.visit_Constant+  r  r)   c                    | j                   j                  |j                        }| j                  || j                         S r8   )r   r   sr   )ry   rY   r:   r\   s       r'   	visit_StrzBaseExprVisitor.visit_Str/  s/    xx'~~dDHH--r)   c           	         | j                   j                  |j                  D cg c]#  } | j                  |      | j                         % c}      }| j	                  || j                         S c c}w r8   )r   r   eltsr   r   )ry   rY   r:   r   r\   s        r'   
visit_ListzBaseExprVisitor.visit_List3  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_Index9  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   rQ   slicer   r   r   AttributeErrorr   r   )
ry   rY   r:   pd_evalrQ   slobjresultvr   r\   s
             r'   visit_SubscriptzBaseExprVisitor.visit_Subscript=  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   rQ   upperstepr  )ry   rY   r:   r'  r(  r)  s         r'   visit_SlicezBaseExprVisitor.visit_SliceQ  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

        r@   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)rA   targetsr   rP   rW   Namer   target
ValueErrorr   r   r	  r[   r   rQ   )ry   rY   r:   r   s       r'   visit_AssignzBaseExprVisitor.visit_Assign_  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                   |j                   }|j                  }|j                  }t        |t        j
                        r_| j                  |      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)NzInvalid Attribute context )attrrQ   ctxrP   rW   Loadr   r[   r   r   r   r   r-  r	  r/  rU   r_   )	ry   rY   r:   r2  rQ   r3  resolvedr$  r\   s	            r'   visit_AttributezBaseExprVisitor.visit_Attribute}  s    yy

hhc388$zz%(..HHd+xx''*~~dDHH55 5d3i6H6H5IJKK " eSXX.588t3C#O	s   AB? ?4C75C7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 rQ   z
Function "z$" does not support keyword argumentsz keyword error in function call 'rw   )r\   r   )rP   funcrW   	Attributer2  r6  r-  r   r   r   r   r	  r/  r   rQ   r9   keywordsr\   r   keywordargr   r   )	ry   rY   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$ IILL>, 
 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 r8   r"   )ry   r   s     r'   translate_InzBaseExprVisitor.translate_In  s    	r)   c           
     ,   |j                   }|j                  }t        |      dk(  rJ| j                  |d         }t	        j
                  ||j                  |d         }| j                  |      S |j                  }g }t        ||      D ]P  \  }}	| j                  t	        j                  |	g|| j                  |      g            }
|	}|j                  |
       R | j                  t	        j                  t	        j                         |            S )Nr@   r   )r   r   r   )comparatorsr   r   )r   values)r   rD  rA   rB  rW   r   r   r   zipCompareappendBoolOpr   )ry   rY   r:   r   compsr   r   r   rE  compnew_nodes              r'   visit_ComparezBaseExprVisitor.visit_Compare  s    hh   u:?""3q6*BII$))58DE::e$$ yyC 	$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 r8   )rP   r   r   r   )ry   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 r8   )rP  r   r   r   )rG   yr   r   r   r   rY   ry   s         r'   r   z-BaseExprVisitor.visit_BoolOp.<locals>.visitor  s[    ''*C''*C%)%@%@sC%P"B#s--b$''3DDr)   )rE  r   )ry   rY   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  r8   )9r_   
__module____qualname____doc__r   r   __annotations__r   r   r   r   r   r   binary_op_nodesdictrF  binary_op_nodes_mapr   	unary_opsunary_op_nodesunary_op_nodes_maprW   r   r   r   r   r   rM   r   r   r   r   r   r   r   r   r   r  r  r  r
  r  r  r  r  r  visit_Tupler  r%  r*  r0  r6  r@  rB  rM  rP  rU  r"   r)   r'   r   r   R  sM   
 (0J$/&*I#*->JO* s:?@I4Nc)^<= 			399		399	K '&6? '*0,6).	
" (?%NE
.
;555.. K&2()0<L(1;fC*
	)r)   r   )DictrI  r   r   )rI  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 r8   superr   ry   r   r   r   r   	__class__s        r'   r   zPandasExprVisitor.__init__  s     	ffi8r)   rV  )r_   r[  r\  r   rM   rC   r5   r2   r   r   __classcell__rn  s   @r'   ri  ri    s2     (9;UV

9 

9 
9r)   ri  r   c                  *     e Zd Zddf	 d fdZ xZS )PythonExprVisitorc                    | S r8   r"   rK   s     r'   r=   zPythonExprVisitor.<lambda>  s    F r)   c                ,    t         |   ||||       y )N)r   rk  rm  s        r'   r   zPythonExprVisitor.__init__  s     	ff	Br)   r8   rV  )r_   r[  r\  r   ro  rp  s   @r'   rr  rr    s     .KC	C Cr)   rr  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)rj   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 )Nr@   )level)	r   r   r   r   r   PARSERS_visitorr   terms)ry   r   r   r   r   rw  s         r'   r   zExpr.__init__  s[     	0%eai0$++t{{KZZ\
r)   c                0    t        | j                  dd       S )Nr   )r[   ry  ry   s    r'   r   zExpr.assigner+  s    t}}j$77r)   c                8    | j                  | j                        S r8   )rz  r   r|  s    r'   r8  zExpr.__call__/  s    zz$((##r)   c                @    t        j                  | j                        S r8   )r   pprint_thingrz  r|  s    r'   __repr__zExpr.__repr__2  s    $$TZZ00r)   c                ,    t        | j                        S r8   )rA   r   r|  s    r'   __len__zExpr.__len__5  s    499~r)   c                L    | j                   j                  | j                        S )z&
        Parse an expression.
        )ry  r   r   r|  s    r'   r   z
Expr.parse8  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r8   )r\   )rF   terms     r'   rH   zExpr.names.<locals>.<genexpr>E  s     GtGrg   )r   rz  ra   r\   comflattenr|  s    r'   namesz
Expr.names>  sD    
 4::djjoo.//Gs{{4::/FGGGr)   )numexprr  Nr   )
r   r   r   r   r   zScope | Nonerw  intr   rW  )r   r   )r   r  )r_   r[  r\  r]  r^  r   propertyr   r8  r  r  r   r  r"   r)   r'   rj   rj     s    
 
JKK
   " " 	"
 " " 
" 8 8$1. H Hr)   rj   )pythonr  )r$   tuple[int, str]r   r  )rL   r   r   r   )rz   r   r   zCallable[..., None])r   zset[str]r   zCallable[[type[_T]], type[_T]])jr]  
__future__r   rW   	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   r   pandas.core.computation.parsingr   r   pandas.core.computation.scoper   pandas.io.formatsr   r(   r2   r5   r>   rC   rM   rS   listr   r   r   ra   dir
_all_nodesrd   _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_callsri  rr  rj   rx  r"   r)   r'   <module>r     st   # 
     0        " 0 &5&249$ *O=WFF
 	FD, 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& 

V)coo V)  V)r ""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)   