
    `Vgia                       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 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%m&Z& dd
l'm(Z(m)Z) ddl*m+Z+ ddl,m-c m.c 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; e?d e=            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                        ZT e>ej                        ZV e>ej                        ZW e>ej                        ZYes e>ej                        Z[ e;g d      Z\ e;g d      Z]eDeBz  eTz  eVz  eWz  eYz  eHz  e]z  e\z
  Z^e@e^z
  e\z  Z_e^e_z  Z`de` Zae`rJ ea       d.dZb ed      Zcd/dZdd Zeee%dZfd Zg ede^       egef       G d  d!ej                                      Zi e;g d"      Zj e;eez         Zk ede^ejz  eJ e;g d#      z  z
         G d$ d%ei             Zl ede^ejz   e;d&g      z         G d' d(ei             Zm G d) d*      Znemeld+Zoy)0z
:func:`~pandas.eval` parsers.
    )annotationsN)partialreduce	iskeyword)CallableTypeVar)PY39)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)Scopec                $    | \  }}||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      ]/var/www/html/hubwallet-dev/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_booleansr1   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.   r/   r   r"   s      r&   _replace_localsr4   ^   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&   _composerB      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r7   r!   ).0xr:   s     r&   	<genexpr>z_preparse.<locals>.<genexpr>   s     EqtEs   )callabler.   
untokenizer   sourcer:   s    `r&   	_preparserL      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 r7   )
isinstancevalue)rF   ts    r&   r<   z_is_type.<locals>.<lambda>   s    Z+ r(   r!   )rQ   s   `r&   _is_typerR      s     ,+r(   c              #  t   K   | ]0  }t        |t              rt        |t        j                        r| 2 y wr7   )rO   type
issubclassastAST)rE   nodes     r&   rG   rG      s/      $*T377"; 	s   68c              #  <   K   | ]  }t        t        |        y wr7   )getattrrV   )rE   names     r&   rG   rG      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r7   )rU   __name__)rE   rX   
superclasss     r&   rG   z _filter_nodes.<locals>.<genexpr>   s     VDD*9U$--Vs   &&)	frozenset)r_   	all_nodes
node_namess   `  r&   _filter_nodesrc      s     WIVJZ  r(   c                    | j                   S r7   )r^   )rF   s    r&   r<   r<      s
    !** r(   )AssignModuleExpr)YieldGeneratorExpIfExpDictCompSetCompReprLambdaSetrW   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)selfr8   r9   	node_names      r&   r:   z _node_not_implemented.<locals>.f  s    !Ai[0K"LMMr(   r!   )rw   r:   s   ` r&   _node_not_implementedrx      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_nodesrx   setattr)clsrX   
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   )rv   rX   r8   r9   op_class	op_symbols       r&   r:   z_op_maker.<locals>.f2  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|   )itemsrZ   r   r~   )	r   op_attr_namer   opsops_mapopop_nodemade_op
op_classess	           r&   r:   zadd_ops.<locals>.fG  s    &0&6&6&8 	>"L(#,t45Ccl^=#ABG >!"+&'"5GC6'!3W=	>	> 
r(   r!   )r   r:   s   ` r&   add_opsr   B  s    
	 Hr(   c                  *   e Zd ZU dZeZded<   eZe	e
z   ez   ZdZ e eee            ZeZdZ eee      D  ci c]  \  }}||
 c}}} 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 Z(d(dZ)d(dZ*d(dZ+d Z,d Z-e-Z.d Z/d Z0d Z1d Z2d Z3d)d Z4d! Z5d" Z6d# Z7d$ Z8yc c}}} w )*BaseExprVisitorz
    Custom ast walker. Parsers of other engines should subclass this class
    if necessary.

    Parameters
    ----------
    env : Scope
    engine : str
    parser : str
    preparser : callable
    z
type[Term]
const_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 r7   )envengineparser	preparserassigner)rv   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                  z   }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r7   r   )rE   rF   s     r&   rG   z(BaseExprVisitor.visit.<locals>.<genexpr>  s     ;y|;s   z4Python keyword not valid identifier in numexpr queryr|   )rO   strr   rV   fix_missing_locationsparseSyntaxErroranysplitmsgrT   r^   rZ   )rv   rX   r9   cleanemethodvisitors          r&   visitzBaseExprVisitor.visit  s    dC NN4(E0051AB DJ///$'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   )r@   bodyr   r   )rv   rX   r9   exprs       r&   visit_ModulezBaseExprVisitor.visit_Module  sA    tyy>QCDDyy|tzz$)&))r(   c                <     | j                   |j                  fi |S r7   r   rP   rv   rX   r9   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 r7   )r   rT   r   rewrite_mapmap_is_list_is_strr   add_tmprP   	term_typer   )rv   rX   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   )rv   rX   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 )NrP   )
npdtypefloat32	is_scalarhasattrreturn_typer   r   rP   r   )rv   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 r7   )evaluater   r   r   r   )rv   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 'rt   pytablesis_datetimeFr   )
has_invalid_return_type	TypeErrorr   rT   r   r   rZ   r   
binary_opsobject)rv   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 r7   )r   r   r   )rv   rX   r9   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 r7   )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 r7   )r   r   operand)rv   rX   r9   r   r  s        r&   visit_UnaryOpzBaseExprVisitor.visit_UnaryOp  s0    ZZ **T\\*'{r(   c                R     | j                   |j                  | j                  fi |S r7   )r   idr   r   s      r&   
visit_NamezBaseExprVisitor.visit_Name$  s"    t~~dggtxx:6::r(   c                N    | j                  |j                  | j                        S r7   )r   rP   r   r   s      r&   visit_NameConstantz"BaseExprVisitor.visit_NameConstant'  s    tzz48844r(   c                N    | j                  |j                  | j                        S r7   r   nr   r   s      r&   	visit_NumzBaseExprVisitor.visit_Num*      tvvtxx00r(   c                N    | j                  |j                  | j                        S r7   r  r   s      r&   visit_ConstantzBaseExprVisitor.visit_Constant-  r  r(   c                    | j                   j                  |j                        }| j                  || j                         S r7   )r   r   sr   )rv   rX   r9   r[   s       r&   	visit_StrzBaseExprVisitor.visit_Str0  s/    xx'~~dDHH--r(   c           	         | j                   j                  |j                  D cg c]#  } | j                  |      | j                         % c}      }| j	                  || j                         S c c}w r7   )r   r   eltsr   r   )rv   rX   r9   r   r[   s        r&   
visit_ListzBaseExprVisitor.visit_List4  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   rP   slicer   r   r   AttributeErrorr   r   )
rv   rX   r9   pd_evalrP   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   rP   upperstepr  )rv   rX   r9   r%  r&  r'  s         r&   visit_SlicezBaseExprVisitor.visit_SliceR  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)r@   targetsr   rO   rV   Namer   target
ValueErrorr   r   r  rZ   r   rP   )rv   rX   r9   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 )attrrP   ctxrO   rV   Loadr   rZ   r   r   r   r  r+  r  r-  rT   r^   )	rv   rX   r9   r0  rP   r1  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 rP   z
Function "z$" does not support keyword argumentsz keyword error in function call 'rt   )r[   r   )rO   funcrV   	Attributer0  r4  r+  r   r   r   r   r  r-  r   rP   r8   keywordsr[   keywordargr   r   r   )	rv   rX   r   r9   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  >! :>C#

3--CHC}} 	B!#s{{3$ IILL>, 
 77&*jj&;&A&AF377O	B 88##C$<V$<=D>>t>::W * "499<<0C!  $ > Ds6   
I  ?I?"J 	I<
I*)I<*I55I<;I<c                    |S r7   r!   )rv   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   rB  r@   r@  rV   r   r   r   zipCompareappendBoolOpr   )rv   rX   r9   r   compsr   r   r   rC  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 r7   )rO   r   r   r   )rv   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 r7   )rN  r   r   r   )rF   yr   r   r   r   rX   rv   s         r&   r   z-BaseExprVisitor.visit_BoolOp.<locals>.visitor  s[    ''*C''*C%)%@%@sC%P"B#s--b$''3DDr(   )rC  r   )rv   rX   r9   r   operandss   ``   r&   visit_BoolOpzBaseExprVisitor.visit_BoolOp  s!    	E ;;gx((r(   r   None)NN))inznot in)r    z!=<>z<=z>=)r   r   r7   )9r^   
__module____qualname____doc__r   r   __annotations__r   r   r   r   r   r   binary_op_nodesdictrD  binary_op_nodes_mapr   	unary_opsunary_op_nodesunary_op_nodes_maprV   r   r   r   r   r   rL   r   r   r   r   r   r   r   r   r   r   r  r  r  r	  r  r  r  r  visit_Tupler  r#  r(  r.  r4  r>  r@  rK  rN  rS  )rE   kr"  s   000r&   r   r   U  s^   
 &J
%I->JO* s:?@I4N+.y.+IJJ41a!Q$J 			399		399	K '&6? '*0,8).	
" (?%NE
.
;511.. K&2()0<L(4;lC*
	)I Ks   Dr   )DictrG  r   r   )rG  r8  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 r7   superr   rv   r   r   r   r   	__class__s        r&   r   zPandasExprVisitor.__init__  s     	ffi8r(   rT  )r^   rY  rZ  r   rL   rB   r4   r1   r   r   __classcell__rm  s   @r&   rh  rh    s2     (9;UV

9 

9 
9r(   rh  r   c                  *     e Zd Zddf	 d fdZ xZS )PythonExprVisitorc                    | S r7   r!   rJ   s     r&   r<   zPythonExprVisitor.<lambda>
  s    F r(   c                ,    t         |   ||||       y )N)r   rj  rl  s        r&   r   zPythonExprVisitor.__init__	  s     	ff	Br(   r7   rT  )r^   rY  rZ  r   rn  ro  s   @r&   rq  rq    s     .KC	C Cr(   rq  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)rg   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)rv   r   r   r   r   rv  s         r&   r   zExpr.__init__   s[     	0%eai0$++t{{KZZ\
r(   c                0    t        | j                  dd       S )Nr   )rZ   rx  rv   s    r&   r   zExpr.assigner/  s    t}}j$77r(   c                8    | j                  | j                        S r7   )ry  r   r{  s    r&   r6  zExpr.__call__3  s    zz$((##r(   c                @    t        j                  | j                        S r7   )printingpprint_thingry  r{  s    r&   __repr__zExpr.__repr__6  s    $$TZZ00r(   c                ,    t        | j                        S r7   )r@   r   r{  s    r&   __len__zExpr.__len__9  s    499~r(   c                L    | j                   j                  | j                        S )z&
        Parse an expression.
        )rx  r   r   r{  s    r&   r   z
Expr.parse<  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r7   )r[   )rE   terms     r&   rG   zExpr.names.<locals>.<genexpr>I  s     GtGs   )r   ry  r`   r[   comflattenr{  s    r&   namesz
Expr.namesB  sD    
 4::djjoo.//Gs{{4::/FGGGr(   )numexprr  Nr   )
r   r   r   r   r   zScope | Nonerv  intr   rU  )r   r   )r   r  )r^   rY  rZ  r[  r\  r   propertyr   r6  r  r  r   r  r!   r(   r&   rg   rg     s    
 
JKK
   " " 	"
 " " 
" 8 8$1. H Hr(   rg   )pythonr  )r#   tuple[int, str]r   r  )rK   r   r   r   )rw   r   r   zCallable[..., None])r   zset[str]r   zCallable[[type[_T]], type[_T]])pr[  
__future__r   rV   	functoolsr   r   r:  r   r.   typingr   r	   numpyr   pandas.compatr
   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.formats.printingioformatsr~  r'   r1   r4   r=   rB   rL   rR   listr   r   r   r`   dir
_all_nodesrc   r   _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_nodesr  _slice_nodes_hacked_nodes_unsupported_expr_nodes_unsupported_nodes_base_supported_nodesintersection_msgrx   ry   r   r   _op_classesr   NodeVisitorr   _python_not_supported_numexpr_supported_callsrh  rq  rg   rw  r!   r(   r&   <module>r     s   # 
  
   0        " 0 - -5&249$ *O=WFF
 	FD, D>
3-  9C9 
 )3 ! C 4jAB377#
CHH%CHH%#C$4$45 cjj)-,cii($S%6%67 s001 / s{{+SYY' +L 67 $ $   	
    	  )+==N !$99	-l^<   T]0, 1& 

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