
    Bib                       d Z ddlmZ ddlZddlmZmZ ddlmZ ddl	Z	ddl
mZmZmZ ddlZddlmZ ddlmZ ddlmc mZ dd	lmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& dd
l'm(Z(m)Z) ddl*m+Z+ ddl,m-Z- d7dZ.d7dZ/d7dZ0d Z1d Z2 e2e0e/e.e(          fd8dZ3d Z4 e4e5          Z6 e4e7          Z8 e9d d  e:e          D             D                       Z;e;fdZ< e9d e;D                       Z= e<ej>                  Z? e<ej@                  ZA e<ejB                  ZC e<ejD                  ZE e<ejF                  ZG e<ejH                  ZI e<ejJ                  ZK e<ejL                  ZM e<ejN                  ZO e<ejP                  ZQ e<ejR                  ZS e<ej                  ZT e<ejU                  ZV e9g d          ZW e9g d          ZXeAe?z  eQz  eSz  eTz  eVz  eEz  eXz  eWz
  ZYe=eYz
  eWz  ZZeYeZz  Z[de[ Z\e[r
J e\            d9d"Z] ed#          Z^d:d'Z_d( Z`e e%d)Zad* Zb e_eY           ebea           G d+ d,ejc                                          Zd e9g d-          Ze e9eez             Zf e_eYeez  eG e9g d.          z  z
             G d/ d0ed                      Zg e_eYeez   e9d1g          z             G d2 d3ed                      Zh G d4 d5          Ziehegd6ZjdS );z
:func:`~pandas.eval` parsers.
    )annotationsN)partialreduce	iskeyword)CallableClassVarTypeVar)UndefinedVariableError)is_string_dtype)ARITH_OPS_SYMSBOOL_OPS_SYMSCMP_OPS_SYMS	LOCAL_TAGMATHOPS
REDUCTIONSUNARY_OPS_SYMSBinOpConstantFuncNodeOpTermUnaryOpis_term)clean_backtick_quoted_tokstokenize_string)Scope)printingtoktuple[int, str]returnc                $    | \  }}||dk    rdn|fS )a`  
    Rewrite the assignment operator for PyTables expressions that use ``=``
    as a substitute for ``==``.

    Parameters
    ----------
    tok : tuple of int, str
        ints correspond to the all caps constants in the tokenize module

    Returns
    -------
    tuple of int, str
        Either the input or token or the replacement values
    === r   toknumtokvals      t/var/www/development/aibuddy-work/election-extract/venv/lib/python3.11/site-packages/pandas/core/computation/expr.py_rewrite_assignr*   3   s$     NFF6S==44f44    c                    | \  }}|t           j        k    r,|dk    rt           j        dfS |dk    rt           j        dfS ||fS ||fS )aj  
    Replace ``&`` with ``and`` and ``|`` with ``or`` so that bitwise
    precedence is changed to boolean precedence.

    Parameters
    ----------
    tok : tuple of int, str
        ints correspond to the all caps constants in the tokenize module

    Returns
    -------
    tuple of int, str
        Either the input or token or the replacement values
    &and|or)tokenizeOPNAMEr&   s      r)   _replace_booleansr4   F   sZ     NFFS===%''s]]=$&&v~6>r+   c                f    | \  }}|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.
    @)r1   r2   r   r&   s      r)   _replace_localsr7   _   s9    ( 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     11QQ%7%7%7#8#8 r+   r%   )r=   r>   s   ``r)   	_compose2r@   y   s     988888r+   c                 f    t          |           dk    s
J d            t          t          |           S )z&
    Compose 2 or more callables.
       z.At least 2 callables must be passed to compose)lenr   r@   )funcss    r)   _composerE      s.     u::>>>K>>>)U###r+   sourcestrc                    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   | ]} |          V  d S r:   r%   ).0xr=   s     r)   	<genexpr>z_preparse.<locals>.<genexpr>   s+      EEqqttEEEEEEr+   )callabler1   
untokenizer   rF   r=   s    `r)   	_preparserP      sN    < A;;,,,,,,EEEE_V-D-DEEEEEEr+   c                      fdS )zO
    Factory for a type checking function of type ``t`` or tuple of types.
    c                .    t          | j                  S r:   )
isinstancevalue)rK   ts    r)   r?   z_is_type.<locals>.<lambda>   s    Z++ r+   r%   )rU   s   `r)   _is_typerV      s     ,++++r+   c              #  x   K   | ]5}t          |t                    t          |t          j                  1|V  6d S r:   )rS   type
issubclassastAST)rJ   nodes     r)   rL   rL      s\        $ #-T37";";     r+   c              #  @   K   | ]}t          t          |          V  d S r:   )getattrrZ   )rJ   names     r)   rL   rL      s,      99d##999999r+   c                >      fd|D             }t          |          S )zE
    Filter out AST nodes that are subclasses of ``superclass``.
    c              3  F   K   | ]}t          |          |j        V  d S r:   )rY   __name__)rJ   r\   
superclasss     r)   rL   z _filter_nodes.<locals>.<genexpr>   s4      VVDD*9U9UV$-VVVVVVr+   )	frozenset)rc   	all_nodes
node_namess   `  r)   _filter_nodesrg      s-     WVVVIVVVJZ   r+   c              #  $   K   | ]}|j         V  d S r:   )rb   rJ   rK   s     r)   rL   rL      s$      ;;1AJ;;;;;;r+   )AssignModuleExpr)YieldGeneratorExpIfExpDictCompSetCompReprLambdaSetr[   IsIsNotz$cannot both support and not support 	node_nameCallable[..., None]c                      fd}|S )zV
    Return a function that raises a NotImplementedError with a passed node name.
    c                *    t          d d          )N'z' nodes are not implemented)NotImplementedError)selfr;   r<   rw   s      r)   r=   z _node_not_implemented.<locals>.f  s    !"Li"L"L"LMMMr+   r%   )rw   r=   s   ` r)   _node_not_implementedr~      s(    
N N N N N Hr+   _Tnodesset[str]Callable[[type[_T]], type[_T]]c                     d fd}|S )z
    Decorator to disallow certain nodes from parsing. Raises a
    NotImplementedError instead.

    Returns
    -------
    callable
    clstype[_T]r!   c                    d| _         D ]8}t          |          }d| }| xj         |fz  c_         t          | ||           9| S )Nr%   visit_)unsupported_nodesr~   setattr)r   r\   
new_methodr_   r   s       r)   
disallowedzdisallow.<locals>.disallowed  sb     " 	+ 	+D.t44J"D??D!!dW,!!Cz****
r+   )r   r   r!   r   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|R i |S )z
        Return a partial function with an Op subclass with an operator already passed.

        Returns
        -------
        callable
        )r   )r}   r\   r;   r<   op_class	op_symbols       r)   r=   z_op_maker.<locals>.f0  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                                                     D ]^\  }}t          | | d          }t          | | d          }|D ]0}||         }|$t          ||          }t          | d| |           1_| 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>.fE  s    &0&6&6&8&8 	> 	>"L(#,44455Ccl#A#A#ABBG > >!"+&'"55GC!3'!3!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j        ej        ej        ej        ej        ej        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% Z2d0d&Z3d' Z4d( Z5d) Z6d* Z7dS )1BaseExprVisitorz
    Custom ast walker. Parsers of other engines should subclass this class
    if necessary.

    Parameters
    ----------
    env : Scope
    engine : str
    parser : str
    preparser : callable
    zClassVar[type[Term]]
const_type	term_type)GtLtGtELtEEqNotEqInNotInBitAndBitOrAndOrAddSubMultDivPowFloorDivMod)UAddUSubInvertNotztuple[str, ...]r   r!   Nonec                L    || _         || _        || _        || _        d | _        d S r:   )envengineparser	preparserassigner)r}   r   r   r   r   s        r)   __init__zBaseExprVisitor.__init__  s)    "r+   c                   t          |t                    r|                     |          }	 t          j        t          j        |                    }nF# t          $ r9}t          d |                                D                       rd|_	        |d }~ww xY wdt          |          j         }t          | |          } ||fi |S )Nc              3  4   K   | ]}t          |          V  d S r:   r   ri   s     r)   rL   z(BaseExprVisitor.visit.<locals>.<genexpr>  s(      ;;y||;;;;;;r+   z4Python keyword not valid identifier in numexpr queryr   )rS   rG   r   rZ   fix_missing_locationsparseSyntaxErroranysplitmsgrX   rb   r^   )r}   r\   r<   cleanemethodvisitors          r)   visitzBaseExprVisitor.visit  s    dC   	NN4((E051A1ABB   ;;U[[]];;;;; SRAE
 0$t**-//$''wt&&v&&&s   &A 
B4BBc                    t          |j                  dk    rt          d          |j        d         } | j        |fi |S )NrB   z#only a single expression is allowedr   )rC   bodyr   r   )r}   r\   r<   exprs       r)   visit_ModulezBaseExprVisitor.visit_Module  sI    ty>>QCDDDy|tz$))&)))r+   c                (     | j         |j        fi |S r:   r   rT   r}   r\   r<   s      r)   
visit_ExprzBaseExprVisitor.visit_Expr  s    tz$*/////r+   c                H   |j         }t          |          }t          |          rt          |          r|| j        v rt	          t
          ||f          \  }}t	          t          ||f          \  }}	|s|s|s|	r | j        |                     }|	r;| j                            |j	        g          }
| 
                    |
| j                  }|r;| j                            |j	        g          }
| 
                    |
| j                  }|                     |          }||||fS r:   )r   rX   r   rewrite_mapmap_is_list_is_strr   add_tmprT   r   r   )r}   r\   leftrightop_instanceop_type	left_list
right_listleft_str	right_strr_   r   s               r)   _rewrite_membership_opz&BaseExprVisitor._rewrite_membership_op  s2   g{## 4== 	6WU^^ 	64;K0K0K$'4-$@$@!Iz"%ge}"="=Hi  :J :( :i :7d.w799  7x''66tTX66 6x''55~~dDH55ZZ$$;e++r+   Nc                    ||                      |j        d          }||                      |j        d          }|                     |||          \  }}}}||||fS )Nr   )sider   )r   r   r   r   )r}   r\   r   r   r   r   s         r)   _maybe_transform_eq_nez&BaseExprVisitor._maybe_transform_eq_ne  si    <::dif:55D=JJtzJ88E$($?$?dE$R$R!HdE8T5((r+   c                   t          j        t           j                  }|j        rnt	          |d          r^|j        sW|j        |k    rL| j                            t          j        |j                            }| 	                    || j                  }|j        rnt	          |d          r^|j        sW|j        |k    rL| j                            t          j        |j                            }| 	                    || j                  }||fS )NrT   )
npdtypefloat32	is_scalarhasattrreturn_typer   r   rT   r   )r}   r   r   f32r_   s        r)   _maybe_downcast_constantsz)BaseExprVisitor._maybe_downcast_constants  s    hrz""N	2g&&	2 O	2 !S(( 8##BJtz$:$:;;D>>$11DO	3w''	3 N	3  C'' 8##BJu{$;$;<<DNN422EU{r+   c                \    |                     | j        | j        | j        | j        |          S r:   )evaluater   r   r   r   )r}   binopeval_in_pythons      r)   _maybe_evalzBaseExprVisitor._maybe_eval  s-     ~~Hdk4;
 
 	
r+   inznot inr$   z!=<>z<=z>=c           	         |||          }|j         r(t          d|j         d|j         d|j         d          | j        dk    rK|j        t
          v rt          |dd          st          |dd          r|                     || j                  S |j        |v r|                     ||          S | j        dk    rt          |dd           t          k    sVt          t          |dd                     s8t          |dd           t          k    st          t          |dd                     r|                     |||z             S |S )	Nz unsupported operand type(s) for z: 'z' and 'r{   pytablesis_datetimeFr   )has_invalid_return_type	TypeErrorr   rX   r   r   r^   r   
binary_opsobjectr   )r}   r   r   lhsrhsr   maybe_eval_in_pythonress           r)   _maybe_evaluate_binopz%BaseExprVisitor._maybe_evaluate_binop  s}    bcll& 	136 1 1H1 1%(X1 1 1  
 ;*$$Fl""]E22 #sM511 # ##C9996^####C888[J&&]D11V;;"73t#D#DEE <3t44>>"73t#D#DEE ?
 ''^>R-RSSS
r+   c                    |                      |          \  }}}}|                     ||          \  }}|                     ||||          S r:   )r   r   r	  )r}   r\   r<   r   r   r   r   s          r)   visit_BinOpzBaseExprVisitor.visit_BinOp  sQ    $($?$?$E$E!HdE44T5AAe))"heDDDr+   c                    |                      |j                  }|                      |j                  } ||          S r:   )r   r   operand)r}   r\   r<   r   r  s        r)   visit_UnaryOpzBaseExprVisitor.visit_UnaryOp  s6    ZZ  **T\**r'{{r+   r   c                4     | j         |j        | j        fi |S r:   )r   idr   r   s      r)   
visit_NamezBaseExprVisitor.visit_Name   s"    t~dgtx::6:::r+   c                B    |                      |j        | j                  S r:   r   rT   r   r   s      r)   visit_NameConstantz"BaseExprVisitor.visit_NameConstant$      tz48444r+   c                B    |                      |j        | j                  S r:   r  r   s      r)   	visit_NumzBaseExprVisitor.visit_Num(  r  r+   c                B    |                      |j        | j                  S r:   r  r   s      r)   visit_ConstantzBaseExprVisitor.visit_Constant+  r  r+   c                v    | j                             |j                  }|                     || j                   S r:   )r   r   sr   r}   r\   r<   r_   s       r)   	visit_StrzBaseExprVisitor.visit_Str/  s/    x''~~dDH---r+   c                      j                              fd|j        D                       }                     | j                   S )Nc                V    g | ]%}                      |          j                  &S r%   r   r   )rJ   r   r}   s     r)   
<listcomp>z.BaseExprVisitor.visit_List.<locals>.<listcomp>4  s/     L L LQAtx!8!8 L L Lr+   )r   r   eltsr   r  s   `   r)   
visit_ListzBaseExprVisitor.visit_List3  sE    x L L L L$) L L LMM~~dDH---r+   c                6    |                      |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        |         }n6# t          $ r)  ||| j        | j        | j                  }||         }Y nw xY w| j        	                    |          }	| 
                    |	| j                  S )Nr   )eval)
local_dictr   r   )r   )pandasr'  r   rT   slicer   r   r   AttributeErrorr   r   )
r}   r\   r<   pd_evalrT   slobjresultvr  r_   s
             r)   visit_SubscriptzBaseExprVisitor.visit_Subscript=  s    ******

4:&&

4:&&dht{4;
 
 
	F#AA 	 	 	'$(4;t{  C FAAA	 x""~~d~111s   A( (0BBr*  c                    |j         }||                     |          j        }|j        }||                     |          j        }|j        }||                     |          j        }t          |||          S )zdf.index[slice(4,6)])lowerr   rT   upperstepr*  )r}   r\   r<   r2  r3  r4  s         r)   visit_SlicezBaseExprVisitor.visit_SliceQ  sw    
JJu%%+E
JJu%%+Ey::d##)DUE4(((r+   c                   t          |j                  dk    rt          d          t          |j        d         t          j                  st          d          | j        j        t          d          	  | j	        |j        d         fi |}n"# t          $ r |j        d         j        }Y nw xY wt          |d|          | _        | j        t          d           | j	        |j        fi |S )	z
        support a single assignment node, like

        c = a + b

        set the assigner at the top level, must be a Name node which
        might or might not exist in the resolvers

        rB   z#can only assign a single expressionr   z5left hand side of an assignment must be a single nameNz%cannot assign without a target objectr_   z@left hand side of an assignment must be a single resolvable name)rC   targetsr   rS   rZ   Namer   target
ValueErrorr   r   r  r^   r   rT   )r}   r\   r<   r   s       r)   visit_AssignzBaseExprVisitor.visit_Assign_  s    t|!!CDDD$,q/3844 	WUVVV8?"DEEE	*!tz$,q/<<V<<HH% 	* 	* 	*|A)HHH	*  &(;;= R   tz$*/////s   8B B10B1c                   |j         }|j        }|j        }t          |t          j                  r|                     |          j        }	 t          ||          }| j        	                    |          }| 
                    || j                  S # t          $ r+ t          |t          j                  r|j        |k    r|cY S  w xY wt          dt          |          j                   )NzInvalid Attribute context )attrrT   ctxrS   rZ   Loadr   r^   r   r   r   r+  r8  r  r:  rX   rb   )	r}   r\   r<   r=  rT   r>  resolvedr/  r_   s	            r)   visit_AttributezBaseExprVisitor.visit_Attribute}  s    y
hc38$$ 	zz%((.HHd++x''**~~dDH555!   eSX.. $58t3C3C#OOO	 Jd3ii6HJJKKKs   AB 1CCc                0    t          |j        t          j                  r+|j        j        dk    r                     |j                  }nt          |j        t          j                  st          d          	                      |j                  }n:# t          $ r- 	 t          |j        j                  }n# t          $ r  w xY wY nw xY w|t          d|j        j                   t          |d          r|j        }t          |t                    r7 fd|j        D             }|j        rt          d|j         d           || S  fd|j        D             }|j        D ]p}t          |t          j                  st          d	|j        j         d
          |j        r0                      |j                   j                  ||j        <   q j                             ||i |          }                     | j                  S )N__call__z"Only named functions are supportedzInvalid function call rT   c                :    g | ]}                     |          S r%   )r   rJ   argr}   s     r)   r!  z.BaseExprVisitor.visit_Call.<locals>.<listcomp>  s#    ===C

3===r+   z
Function "z$" does not support keyword argumentsc                V    g | ]%}                      |          j                  &S r%   r   rE  s     r)   r!  z.BaseExprVisitor.visit_Call.<locals>.<listcomp>  s/    GGGc

311GGGr+   z keyword error in function call 'r{   )r_   r   )rS   funcrZ   	Attributer=  rA  r8  r  r   r   r   r  r:  r   rT   r;   keywordsr_   keywordrF  r   r   r   )r}   r\   r   r<   r  new_argskeyr_   s   `       r)   
visit_CallzBaseExprVisitor.visit_Call  s`   di// 	DINj4P4P&&ty11CCDIsx00 	@AAAjj++)   "49<00CC!    C ;777   3   	)Cc8$$ 	;====49===H} OOOO   3>! HGGGTYGGGH} 	F 	F!#s{33 $, IL, , ,  
 7 F&;djj&;&;DH&E&EF37O8##CC$<V$<$<==D>>t>:::s*   ;B 
C!B;:C;CCCc                    |S r:   r%   )r}   r   s     r)   translate_InzBaseExprVisitor.translate_In  s    	r+   c           
     F   |j         }|j        }t          |          dk    rR|                     |d                   }t	          j        ||j        |d                   }|                     |          S |j        }g }t          ||          D ][\  }}	|                     t	          j	        |	g||                     |          g                    }
|	}|
                    |
           \|                     t	          j        t	          j                    |                    S )NrB   r   )r   r   r   )comparatorsr   r   )r   values)r   rR  rC   rP  rZ   r   r   r   zipCompareappendBoolOpr   )r}   r\   r<   r   compsr   r   r   rS  compnew_nodes              r)   visit_ComparezBaseExprVisitor.visit_Compare  s   h  u::??""3q6**BI$)58DDDE::e$$$ yC 	$ 	$HBzzT@Q@QRT@U@U?VWWW H DMM(####zz#*		&AAABBBr+   c                h    t          |t          t          f          r|S |                     |          S r:   )rS   r   r   r   )r}   bops     r)   _try_visit_binopz BaseExprVisitor._try_visit_binop  s-    cB:&& 	Jzz#r+   c                @      fd}j         }t          ||          S )Nc                                         |           }                     |          }                    ||          \  }}}}                    |j        ||          S r:   )r^  r   r	  r   )rK   yr  r  r   r   r\   r}   s         r)   r   z-BaseExprVisitor.visit_BoolOp.<locals>.visitor  se    ''**C''**C%)%@%@sC%P%P"B#s--b$'3DDDr+   )rS  r   )r}   r\   r<   r   operandss   ``   r)   visit_BoolOpzBaseExprVisitor.visit_BoolOp  sA    	E 	E 	E 	E 	E 	E ;gx(((r+   r!   r   )NN)r   r   )r!   r   )r!   r*  r:   )8rb   
__module____qualname____doc__r   r   __annotations__r   r   r   r   r   r  binary_op_nodesdictrT  binary_op_nodes_mapr   	unary_opsunary_op_nodesunary_op_nodes_maprZ   r   r   r   r   r   rP   r   r   r   r   r   r   r   r   r	  r  r  r  r  r  r  r  r#  visit_Tupler%  r0  r5  r;  rA  rN  rP  r[  r^  rc  r%   r+   r)   r   r   S  s        
 
 (0J////&*I****->JO* $ss:??@@I4Ncc)^<<== 		39	39	K '&&&6?     ' ' '* * *0 0 0, , ,6) ) ) )  .	
 	
 	
" (?' ' ' 'RE E E
  
; ; ; ;5 5 5 55 5 5 55 5 5 5. . . .. . . . K& & &2 2 2 2() ) ) )0 0 0<L L L(1; 1; 1; 1;f  C C C*  
	) 	) 	) 	) 	)r+   r   )DictrW  r   r   )rW  rI  r   r   Tuplec                  P     e Zd Z ee eeee                    fd fdZ	 xZ
S )PandasExprVisitor)r=   r!   r   c                P    t                                          ||||           d S r:   superr   r}   r   r   r   r   	__class__s        r)   r   zPandasExprVisitor.__init__  s)     	ffi88888r+   rd  )rb   re  rf  r   rP   rE   r7   r4   r   r   __classcell__rx  s   @r)   rs  rs    sn         'h(9;UVV
 
 

9 
9 
9 
9 
9 
9 
9 
9 
9 
9 
9r+   rs  r   c                  (     e Zd Zddfd fdZ xZS )PythonExprVisitorNc                    | S r:   r%   rO   s     r)   r?   zPythonExprVisitor.<lambda>  s    F r+   r!   r   c                R    t                                          ||||           d S )N)r   ru  rw  s        r)   r   zPythonExprVisitor.__init__  s,     	ff	BBBBBr+   r:   rd  )rb   re  rf  r   ry  rz  s   @r)   r|  r|    sY         .K-J-JC C C C C C C C C C Cr+   r|  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d	S )rl   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   rG   r   r   numexprr)  Nr   Scope | Nonelevelintr!   r   c                    || _         |pt          |dz             | _        || _        || _        t          |         | j        | j        | j                  | _        |                                 | _        d S )NrB   )r  )	r   r   r   r   r   PARSERS_visitorr   terms)r}   r   r   r   r   r  s         r)   r   zExpr.__init__  sd     	0%eai000$+t{KKZZ\\


r+   c                .    t          | j        dd           S )Nr   )r^   r  r}   s    r)   r   zExpr.assigner+  s    t}j$777r+   c                6    |                      | j                  S r:   )r  r   r  s    r)   rC  zExpr.__call__/  s    zz$(###r+   c                4    t          j        | j                  S r:   )r   pprint_thingr  r  s    r)   __repr__zExpr.__repr__2  s    $TZ000r+   c                *    t          | j                  S r:   )rC   r   r  s    r)   __len__zExpr.__len__5  s    49~~r+   c                @    | j                             | j                  S )z&
        Parse an expression.
        )r  r   r   r  s    r)   r   z
Expr.parse8  s     }""49---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  $   K   | ]}|j         V  d S r:   )r_   )rJ   terms     r)   rL   zExpr.names.<locals>.<genexpr>E  s$      GGtGGGGGGr+   )r   r  rd   r_   comflattenr  s    r)   namesz
Expr.names>  sT    
 4: 	0djo.///GGs{4:/F/FGGGGGGr+   )r  r)  Nr   )
r   rG   r   rG   r   r  r  r  r!   r   )r!   rG   )r!   r  )rb   re  rf  rg  rh  r   propertyr   rC  r  r  r   r  r%   r+   r)   rl   rl     s         
 
 JJJKKKKKK
   " " " " " 8 8 X8$ $ $1 1 1 1   . . . H H XH H Hr+   rl   )pythonr)  )r   r    r!   r    )rF   rG   r!   rG   )rw   rG   r!   rx   )r   r   r!   r   )krg  
__future__r   rZ   	functoolsr   r   rK  r   r1   typingr   r	   r
   numpyr   pandas.errorsr   pandas.core.dtypes.commonr   pandas.core.commoncorecommonr  pandas.core.computation.opsr   r   r   r   r   r   r   r   r   r   r   r   r   r   pandas.core.computation.parsingr   r   pandas.core.computation.scoper   pandas.io.formatsr   r*   r4   r7   r@   rE   rP   rV   listr   rG   r   rd   dir
_all_nodesrg   _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_callsrs  r|  rl   r  r%   r+   r)   <module>r     s    # " " " " " 



                            0 0 0 0 0 0 5 5 5 5 5 5                                                          0 / / / / / & & & & & &5 5 5 5&   2   49 9 9$ $ $ h*O=W F F F F FD, , , 8D>>
(3-- Y  99C999    
 )3 ! ! ! ! );;
;;;;;]37##
mCH%%mCH%%#mC$455 cj))----,,ci(($}S%677 s011 =// s{++}SY'' 	66677 $)    $   	
    	  )+==N !$99<l<<         WT]]   0  , 11  & 

U) U) U) U) U)co U) U)  U)p "	"C"C"CDD $9Z'%9::  
//yy!P!P!PQQQS 9 9 9 9 9 9 9	 9 

4
4yy%7I7I
IJJC C C C C C C KJC:H :H :H :H :H :H :H :Hz '2C
D
Dr+   