
    Owga                    ~   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$ 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 Z/d Z0 e0e.e-e,e&      f	 	 	 d-dZ1d Z2 e2e3      Z4 e2e5      Z6 e7d d  e8e      D        D              Z9e9fdZ: e7d e9D              Z; e:ejx                        Z= e:ej|                        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                        ZR e:ej                        ZT e7g d      ZU e7g d      ZVe?e=z  eOz  eQz  eRz  eTz  eCz  eVz  eUz
  ZWe;eWz
  eUz  ZXeWeXz  ZYdeY ZZeYrJ eZ       d.dZ[ ed      Z\d/dZ]d Z^ee#dZ_d Z` e]eW       e`e_       G d  d!ej                                      Zb e7g d"      Zc e7eez         Zd e]eWecz  eE e7g d#      z  z
         G d$ d%eb             Ze e]eWecz   e7d&g      z         G d' d(eb             Zf G d) d*      Zgefeed+Zhy)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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      S/var/www/horilla/myenv/lib/python3.12/site-packages/pandas/core/computation/expr.py_rewrite_assignr'   1   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   D   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=   w   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              #  4   K   | ]  }|j                     y wr7   )r^   rE   rF   s     r&   rG   rG      s     ;1AJJ;   )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!   )ry   r:   s   ` r&   _node_not_implementedrz      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_nodesrz   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   )rx   rX   r8   r9   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~   )itemsrZ   r   r   )	r   op_attr_namer   opsops_mapopop_nodemade_op
op_classess	           r&   r:   zadd_ops.<locals>.fC  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(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Mod)UAddUSubInvertNotztuple[str, ...]r   c                J    || _         || _        || _        || _        d | _        y r7   )envengineparser	preparserassigner)rx   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r7   r   re   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   )rx   rX   r9   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   )r@   bodyr   r   )rx   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   rx   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   r   r   )rx   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   )rx   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   )rx   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   )rx   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 'rv   pytablesis_datetimeFr   )
has_invalid_return_type	TypeErrorr   rT   r   r   rZ   r   
binary_opsobject)rx   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   )rx   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                ~    | j                  |j                        }| j                  |j                        } ||      S r7   )r   r   operand)rx   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       tzz48844r(   c                N    | j                  |j                  | j                        S r7   r	  r   s      r&   	visit_NumzBaseExprVisitor.visit_Num$  r  r(   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   )rx   rX   r9   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 r7   )r   r   eltsr   r   )rx   rX   r9   r   r[   s        r&   
visit_ListzBaseExprVisitor.visit_List/  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_Index5  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   )
rx   rX   r9   pd_evalrP   slobjresultvr   r[   s
             r&   visit_SubscriptzBaseExprVisitor.visit_Subscript9  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  )rx   rX   r9   r$  r%  r&  s         r&   visit_SlicezBaseExprVisitor.visit_SliceM  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   )rx   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^   )	rx   rX   r9   r/  rP   r0  resolvedr!  r[   s	            r&   visit_AttributezBaseExprVisitor.visit_Attributey  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 'rv   )r[   r   )rO   funcrV   	Attributer/  r3  r*  r   r   r   r   r  r,  r   rP   r8   keywordsr[   r   keywordargr   r   )	rx   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  >! >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 r7   r!   )rx   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   rA  r@   r?  rV   r   r   r   zipCompareappendBoolOpr   )rx   rX   r9   r   compsr   r   r   rB  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   )rx   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   )rM  r   r   r   )rF   yr   r   r   r   rX   rx   s         r&   r   z-BaseExprVisitor.visit_BoolOp.<locals>.visitor  s[    ''*C''*C%)%@%@sC%P"B#s--b$''3DDr(   )rB  r   )rx   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   )r   r  r7   )8r^   
__module____qualname____doc__r   r   __annotations__r   r   r   r   r   r   binary_op_nodesdictrC  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  visit_Tupler  r"  r'  r-  r3  r=  r?  rJ  rM  rR  r!   r(   r&   r   r   Q  sH   
 (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   )DictrF  r   r   )rF  r7  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   rx   r   r   r   r   	__class__s        r&   r   zPandasExprVisitor.__init__  s     	ffi8r(   rS  )r^   rX  rY  r   rL   rB   r4   r1   r   r   __classcell__rk  s   @r&   rf  rf    s2     (9;UV

9 

9 
9r(   rf  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   rh  rj  s        r&   r   zPythonExprVisitor.__init__  s     	ff	Br(   r7   rS  )r^   rX  rY  r   rl  rm  s   @r&   ro  ro    s     .KC	C Cr(   ro  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)ri   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)rx   r   r   r   r   rt  s         r&   r   zExpr.__init__  s[     	0%eai0$++t{{KZZ\
r(   c                0    t        | j                  dd       S )Nr   )rZ   rv  rx   s    r&   r   zExpr.assigner'  s    t}}j$77r(   c                8    | j                  | j                        S r7   )rw  r   ry  s    r&   r5  zExpr.__call__+  s    zz$((##r(   c                @    t        j                  | j                        S r7   )r   pprint_thingrw  ry  s    r&   __repr__zExpr.__repr__.  s    $$TZZ00r(   c                ,    t        | j                        S r7   )r@   r   ry  s    r&   __len__zExpr.__len__1  s    499~r(   c                L    | j                   j                  | j                        S )z&
        Parse an expression.
        )rv  r   r   ry  s    r&   r   z
Expr.parse4  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>A  s     GtGrf   )r   rw  r`   r[   comflattenry  s    r&   namesz
Expr.names:  sD    
 4::djjoo.//Gs{{4::/FGGGr(   )numexprr  Nr   )
r   r   r   r   r   zScope | Nonert  intr   rT  )r   r   )r   r  )r^   rX  rY  rZ  r[  r   propertyr   r5  r}  r  r   r  r!   r(   r&   ri   ri     s    
 
JKK
   " " 	"
 " " 
" 8 8$1. H Hr(   ri   )pythonr  )r#   tuple[int, str]r   r  )rK   r   r   r   )ry   r   r   zCallable[..., None])r   zset[str]r   zCallable[[type[_T]], type[_T]])irZ  
__future__r   rV   	functoolsr   r   r9  r   r.   typingr   r	   r
   numpyr   pandas.errorsr   pandas.core.commoncorecommonr  pandas.core.computation.opsr   r   r   r   r   r   r   r   r   r   r   r   r   r   pandas.core.computation.parsingr   r   pandas.core.computation.scoper   pandas.io.formatsr   r'   r1   r4   r=   rB   rL   rR   listr   r   r   r`   dir
_all_nodesrc   _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_msgrz   r{   r   r   _op_classesr   NodeVisitorr   _python_not_supported_numexpr_supported_callsrf  ro  ri   ru  r!   r(   r&   <module>r     so   # 
     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& 

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