
    `VgF?                       d Z ddlmZ ddl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mZ ddlmc mZ dd	lmZmZ dd
lmZ ddlmZmZ dZdZdZ ee z   Z!dZ" G d d      Z# G d de#      Z$ddddZ% G d d      Z&d Z'd Z(dZ)ejT                  ejV                  ejX                  ejZ                  ej\                  ej^                  e'e(fZ0 e1 e2e)e0            Z3dZ4ejj                  ejl                  ejj                  ejl                  fZ7 e1 e2e4e7            Z8dZ9ejt                  ejv                  ejx                  ejz                  ej|                  ej~                  ej                  fZA e1 e2e9eA            ZBdZCej|                  ej~                  ej                  fZD e1 e2eCeD            ZEi ZFe3e8eBfD ]  ZGeFj                  eG        d  ZId.d!ZJ G d" d#e&      ZKd.d$ZL G d% d&eK      ZMd'ZNej                  ej                  ej                  ej                  fZR e1 e2eNeR            ZS G d( d)e&      ZT G d* d+e&      ZU G d, d-      ZVy)/z
Operator classes for eval.
    )annotations)datetime)partialN)CallableIterableLiteral)	Timestamp)is_list_like	is_scalar)ensure_decodedresult_type_many)DEFAULT_GLOBALS)pprint_thingpprint_thing_encoded)sumprod)sincosexplogexpm1log1psqrtsinhcoshtanharcsinarccosarctanarccosharcsinharctanhabslog10floorceil)arctan2__pd_eval_local_c                      e Zd ZU d fd	Zded<   dddZedd       ZddZd Z	ddZ
d	 Zdd
Zedd       Zed        ZeZedd       Zedd       Zed        Zej&                  d        Zed        Zedd       Z xZS )Termc                `    t        |t              st        n| }t        t        |  } ||      S N)
isinstancestrConstantsuperr*   __new__)clsnameenvsideencodingklasssupr_new	__class__s          \/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/computation/ops.pyr1   zTerm.__new__F   s)     *4 53u-    boolis_localc                    || _         || _        || _        t        |      }|j	                  t
              xs |t        v | _        | j                         | _	        || _
        y r,   )_namer4   r5   r.   
startswith	LOCAL_TAGr   r=   _resolve_name_valuer6   )selfr3   r4   r5   r6   tnames         r:   __init__zTerm.__init__N   sS    
	D	((3Ou7O((* r;   c                B    | j                   j                  t        d      S )N )r3   replacerA   rD   s    r:   
local_namezTerm.local_nameX   s    yy  B//r;   c                ,    t        | j                        S r,   )r   r3   rJ   s    r:   __repr__zTerm.__repr__\   s    DII&&r;   c                    | j                   S r,   valuerD   argskwargss      r:   __call__zTerm.__call___       zzr;   c                    | S r,    rQ   s      r:   evaluatezTerm.evaluateb   s    r;   c                r   t        | j                        }| j                  }|| j                  j                  v r)t        | j                  j                  |   t              rd}| j                  j                  ||      }| j                  |       t        |d      r|j                  dkD  rt        d      |S )NF)r=   ndim   z?N-dimensional objects, where N > 2, are not supported with eval)r.   rK   r=   r4   scoper-   typeresolveupdatehasattrrZ   NotImplementedError)rD   rK   r=   ress       r:   rB   zTerm._resolve_namee   s    )
=='JHHNN:&-
 HhhzH=C3CHHqL%Q  
r;   c                    | j                   }t        |t              r(| j                  j	                  | j
                  ||       || _        y)z
        search order for local (i.e., @variable) variables:

        scope, key_variable
        [('locals', 'local_name'),
         ('globals', 'local_name'),
         ('locals', 'key'),
         ('globals', 'key')]
        )	new_valueN)r3   r-   r.   r4   swapkeyrK   rP   )rD   rP   keys      r:   r_   zTerm.updatev   s=     ii c3HHT__cUC
r;   c                ,    t        | j                        S r,   )r   rC   rJ   s    r:   r   zTerm.is_scalar   s    %%r;   c                    	 | j                   j                  j                  S # t        $ r@ 	 | j                   j                  cY S # t        $ r t	        | j                         cY cY S w xY ww xY wr,   )rC   valuesdtypeAttributeErrorr]   rJ   s    r:   r]   z	Term.type   s_    		);;%%+++ 	)){{(((! )DKK(()		)s,   " 	A+AA+A'"A+&A''A+c                x    t        |       j                   dt        | j                         d| j                    dS )Nz(name=z, type=))r]   __name__reprr3   rJ   s    r:   rawzTerm.raw   s3    t*%%&fT$))_,=WTYYKqQQr;   c                    	 | j                   j                   }t        |t        t        j
                  f      S # t        $ r | j                   }Y 7w xY wr,   )r]   rk   
issubclassr   np
datetime64rD   ts     r:   is_datetimezTerm.is_datetime   sF    			A !h677  			A	   8 AAc                    | j                   S r,   rC   rJ   s    r:   rP   z
Term.value   s    {{r;   c                    || _         y r,   rz   )rD   rd   s     r:   rP   z
Term.value   s	    r;   c                    | j                   S r,   r?   rJ   s    r:   r3   z	Term.name       zzr;   c                .    | j                   j                  S r,   )rC   rZ   rJ   s    r:   rZ   z	Term.ndim   s    {{r;   NNreturnNoner   r.   )r   r*   r   r<   )r   int)rn   
__module____qualname__r1   __annotations__rF   propertyrK   rM   rT   rX   rB   r_   r   r]   return_typerp   rw   rP   setterr3   rZ   __classcell__r9   s   @r:   r*   r*   E   s     N! 0 0'"$ & & 
) 
) KR R 8 8   \\         r;   r*   c                  @     e Zd Zdd fdZd Zed        ZddZ xZS )r/   c                ,    t         |   ||||       y )N)r5   r6   )r0   rF   )rD   rP   r4   r5   r6   r9   s        r:   rF   zConstant.__init__   s    $Br;   c                    | j                   S r,   r}   rJ   s    r:   rB   zConstant._resolve_name   rU   r;   c                    | j                   S r,   rO   rJ   s    r:   r3   zConstant.name   r~   r;   c                ,    t        | j                        S r,   )ro   r3   rJ   s    r:   rM   zConstant.__repr__   s     DIIr;   r   r   r   )	rn   r   r   rF   rB   r   r3   rM   r   r   s   @r:   r/   r/      s'    C  r;   r/   ~&|)notandorc                      e Zd ZU dZded<   dddZd ZddZed        Z	edd	       Z
ed
        Zedd       Zedd       Zy)Opz.
    Hold an operator of arbitrary arity.
    r.   opNc                V    t         j                  ||      | _        || _        || _        y r,   )_bool_op_mapgetr   operandsr6   )rD   r   r   r6   s       r:   rF   zOp.__init__   s$    ""2r*  r;   c                ,    t        | j                        S r,   )iterr   rJ   s    r:   __iter__zOp.__iter__   s    DMM""r;   c                x    d | j                   D        }t        d| j                   dj                  |            S )zW
        Print a generic n-ary operator and its operands using infix notation.
        c              3  :   K   | ]  }d t        |       d  yw)(rm   N)r   ).0oprs     r:   	<genexpr>zOp.__repr__.<locals>.<genexpr>   s     EQ|C()+Es    )r   r   r   join)rD   pareneds     r:   rM   zOp.__repr__   s5    
 Ft}}EayN//899r;   c                    | j                   t        t        z   v rt        j                  S t        d t        j                  |       D         S )Nc              3  4   K   | ]  }|j                     y wr,   r]   r   terms     r:   r   z!Op.return_type.<locals>.<genexpr>   s     !J$))!J   )r   CMP_OPS_SYMSBOOL_OPS_SYMSrs   bool_r   comflattenrJ   s    r:   r   zOp.return_type   s8     77|m3488O!JD8I!JKKr;   c                    | j                   }t        t        j                  d      g      }| j                  t
        k(  xr ||z
  S )Nobject)operand_types	frozensetrs   rj   r   r   )rD   typesobj_dtype_sets      r:   has_invalid_return_typezOp.has_invalid_return_type   s>    ""!288H#5"676)Cem.CCr;   c                L    t        d t        j                  |       D              S )Nc              3  4   K   | ]  }|j                     y wr,   r   r   s     r:   r   z#Op.operand_types.<locals>.<genexpr>   s     AtAr   )r   r   r   rJ   s    r:   r   zOp.operand_types   s    As{{4/@AAAr;   c                :    t        d | j                  D              S )Nc              3  4   K   | ]  }|j                     y wr,   )r   )r   operands     r:   r   zOp.is_scalar.<locals>.<genexpr>   s     B7$$Br   )allr   rJ   s    r:   r   zOp.is_scalar   s    BDMMBBBr;   c                    	 | j                   j                  }t        |t        t
        j                  f      S # t        $ r | j                   }Y 7w xY wr,   )r   r]   rk   rr   r   rs   rt   ru   s     r:   rw   zOp.is_datetime   sL    	!  %%A !h677  	!  A	!rx   r,   )r   r.   r   zIterable[Term | Op]r   r   r   r   )rn   r   r   __doc__r   rF   r   rM   r   r   r   r   r   rw   rW   r;   r:   r   r      s     	G!
#: L L D D
 B B C C 8 8r;   r   c                    	 | j                  |      S # t        $ r5 t        |       r#	 |j                  |       cY S # t        $ r Y nw xY w| |v cY S w xY w)z`
    Compute the vectorized membership of ``x in y`` if possible, otherwise
    use Python.
    isinrk   r
   xys     r:   _inr     sY    
vvay ?vvay ! Avs/    A;A	AAAAAc                    	 | j                  |       S # t        $ r6 t        |       r$	 |j                  |        cY S # t        $ r Y nw xY w| |vcY S w xY w)zd
    Compute the vectorized membership of ``x not in y`` if possible,
    otherwise use Python.
    r   r   s     r:   _not_inr     s^    
q	z ?q	z!! zs/    A=A	A	AA		AA)><z>=z<=z==z!=inznot in)r   r   r   r   )+-*/**//%)r   r   r   c                   t        j                  |      }| D ]>  }|j                  |v r	 |j                  j	                  |      }|j                  |       @ y# t
        $ r |j                  |j                        }Y :w xY w)a$  
    Cast an expression inplace.

    Parameters
    ----------
    terms : Op
        The expression that should cast.
    acceptable_dtypes : list of acceptable numpy.dtype
        Will not cast if term's dtype in this list.
    dtype : str or numpy.dtype
        The dtype to cast to.
    N)rs   rj   r]   rP   astyperk   r_   )termsacceptable_dtypesrj   dtr   rd   s         r:   _cast_inplacer   L  sz     
%B 99))	,

))"-I 	I  	,

+I	,s   A$B Bc                "    t        | t              S r,   )r-   r*   )objs    r:   is_termr   e  s    c4  r;   c                  @     e Zd ZdZd fdZd ZddZd	dZd Z xZ	S )
BinOpz
    Hold a binary operator and its operands.

    Parameters
    ----------
    op : str
    lhs : Term or Op
    rhs : Term or Op
    c                6   t         |   |||f       || _        || _        | j	                          | j                          	 t        |   | _        y # t        $ r=}t        t        j                               }t        dt        |       d|       |d }~ww xY w)NzInvalid binary operator , valid operators are )r0   rF   lhsrhs_disallow_scalar_only_bool_opsconvert_values_binary_ops_dictfuncKeyErrorlistkeys
ValueErrorro   )rD   r   r   r   errr   r9   s         r:   rF   zBinOp.__init__t  s    c3Z(++-	(,DI 	(--/0D*48*4J4&Q	s   A 	B8BBc                j    | j                  |      }| j                  |      }| j                  ||      S )z
        Recursively evaluate an expression in Python space.

        Parameters
        ----------
        env : Scope

        Returns
        -------
        object
            The result of an evaluated expression.
        )r   r   r   )rD   r4   leftrights       r:   rT   zBinOp.__call__  s/     xx}yyu%%r;   c                b   |dk(  r	 | |      }n| j                   j                  |||||      }| j                  j                  |||||      }| j                  |v r'| j	                  |j
                  |j
                        }nddlm}	  |	| |||      }|j                  |      }
 ||
|      S )al  
        Evaluate a binary operation *before* being passed to the engine.

        Parameters
        ----------
        env : Scope
        engine : str
        parser : str
        term_type : type
        eval_in_python : list

        Returns
        -------
        term_type
            The "pre-evaluated" expression as an instance of ``term_type``
        python)engineparser	term_typeeval_in_pythonr   )eval)
local_dictr   r   )r4   )	r   rX   r   r   r   rP   pandas.core.computation.evalr   add_tmp)rD   r4   r   r   r   r   rb   r   r   r   r3   s              r:   rX   zBinOp.evaluate  s    " Xs)C 88$$#- % D HH%%#- & E ww.(ii

EKK8=4CvN{{33''r;   c                     fd} j                    j                  }}t        |      r|j                  rt        |      r|j                  rv|j
                  }t        |t        t        f      r ||      }t        t        |            }|j                  |j                  d      } j                  j                  |       t        |      r|j                  rt        |      r|j                  rw|j
                  }t        |t        t        f      r ||      }t        t        |            }|j                  |j                  d      } j                   j                  |       yyyyy)zK
        Convert datetimes to a comparable value in an expression.
        c                p    j                   t        t        j                         }nt        } ||       S )N)r6   )r6   r   r   r   )rP   encoderrD   s     r:   	stringifyz'BinOp.convert_values.<locals>.stringify  s-    }}(!"6O&5>!r;   NUTC)r   r   r   rw   r   rP   r-   r   floatr	   r   tz
tz_convertr_   )rD   r  r   r   vs   `    r:   r   zBinOp.convert_values  s   
	" 88TXXS3<COO		A!c5\*aL.+,AttLL'HHOOA3<COO		A!c5\*aL.+,AttLL'HHOOA BOO<r;   c                   | j                   }| j                  }|j                  }t        |d|      }|j                  }t        |d|      }|j                  s|j                  r_| j
                  t        v rLt        |t        t        j                  f      r t        |t        t        j                  f      st        d      y y y )Nr]   z$cannot evaluate scalar only bool ops)r   r   r   getattrr   r   _bool_ops_dictrr   r<   rs   r   ra   )rD   r   r   rhs_rtlhs_rts        r:   r   z$BinOp._disallow_scalar_only_bool_ops  s    hhhh 00]]cmm>) vbhh'78"6D"((+;< &&LMM	 =	 * ,r;   )r   r.   r   r   )r   r.   r   )
rn   r   r   r   rF   rT   rX   r   r   r   r   s   @r:   r   r   i  s$    $&&/(bBNr;   r   c                p    t        t        j                  |       j                  t        j                        S r,   )rr   rs   rj   r]   number)rj   s    r:   	isnumericr    s!    bhhuo**BII66r;   c                  $     e Zd ZdZd fdZ xZS )Divz
    Div operator to special case casting.

    Parameters
    ----------
    lhs, rhs : Term or Op
        The Terms or Ops in the ``/`` expression.
    c           	     ~   t         |   d||       t        |j                        rt        |j                        s3t	        d| j
                   d|j                   d|j                   d      t        j                  t        j                  g}t        t        j                  |       |t        j                         y )Nr   z unsupported operand type(s) for z: 'z' and '')r0   rF   r  r   	TypeErrorr   rs   float32float_r   r   r   )rD   r   r   r   r9   s       r:   rF   zDiv.__init__  s    c3')3??1K2477) <OO$GCOO+<A?   ZZ3ckk$'):BIIFr;   r   )rn   r   r   r   rF   r   r   s   @r:   r  r    s    G Gr;   r  )r   r   r   r   c                  F     e Zd ZdZd fdZddZddZed	d       Z xZ	S )
UnaryOpaK  
    Hold a unary operator and its operands.

    Parameters
    ----------
    op : str
        The token used to represent the operator.
    operand : Term or Op
        The Term or Op operand to the operator.

    Raises
    ------
    ValueError
        * If no function associated with the passed operator token is found.
    c                    t         |   ||f       || _        	 t        |   | _        y # t
        $ r$}t        dt        |       dt               |d }~ww xY w)NzInvalid unary operator r   )	r0   rF   r   _unary_ops_dictr   r   r   ro   UNARY_OPS_SYMS)rD   r   r   r   r9   s       r:   rF   zUnaryOp.__init__3  si    gZ(	'+DI 	)$r( 4''5&68 	s   * 	AAAc                F    | j                  |      }| j                  |      S r,   )r   r   )rD   r4   r   s      r:   rT   zUnaryOp.__call__?  s    ,,s#yy!!r;   c                L    t        | j                   d| j                   d      S )Nr   rm   )r   r   r   rJ   s    r:   rM   zUnaryOp.__repr__D  s"    twwiqa899r;   c                D   | j                   }|j                  t        j                  d      k(  rt        j                  d      S t	        |t
              r9|j                  t        v s|j                  t        v rt        j                  d      S t        j                  d      S )Nr<   r   )	r   r   rs   rj   r-   r   r   _cmp_ops_dictr
  )rD   r   s     r:   r   zUnaryOp.return_typeG  so    ,,"((6"2288F##gr"JJ-'7::+G88F##xxr;   )r   zLiteral['+', '-', '~', 'not']r   r   )r   MathCallr   )r   znp.dtype)
rn   r   r   r   rF   rT   rM   r   r   r   r   s   @r:   r  r  "  s+     
"
:  r;   r  c                  .     e Zd Zd fdZd ZddZ xZS )r   c                H    t         |   |j                  |       || _        y r,   )r0   rF   r3   r   )rD   r   rR   r9   s      r:   rF   zMathCall.__init__T  s    D)	r;   c                    | j                   D cg c]
  } ||       }}t        j                  d      5   | j                  j                  | cd d d        S c c}w # 1 sw Y   y xY w)Nignore)r   )r   rs   errstater   )rD   r4   r   r   s       r:   rT   zMathCall.__call__X  sZ    &*mm4BsG44[[X& 	-!499>>8,	- 	- 5	- 	-s   AAA'c                    t        t        | j                        }t        | j                   ddj                  |       d      S )Nr   ,rm   )mapr.   r   r   r   r   )rD   r   s     r:   rM   zMathCall.__repr__^  s8    sDMM*twwiq();(<A>??r;   r   r   )rn   r   r   rF   rT   rM   r   r   s   @r:   r   r   S  s    -@r;   r   c                      e Zd ZddZd Zy)FuncNodec                j    |t         vrt        d| d      || _        t        t        |      | _        y )N"z" is not a supported function)MATHOPSr   r3   r	  rs   r   )rD   r3   s     r:   rF   zFuncNode.__init__d  s4    wq&CDEE	B%	r;   c                    t        | |      S r,   )r   )rD   rR   s     r:   rT   zFuncNode.__call__j  s    d##r;   N)r3   r.   r   r   )rn   r   r   rF   rT   rW   r;   r:   r*  r*  c  s    &$r;   r*  r   )Wr   
__future__r   r   	functoolsr   operatortypingr   r   r   numpyrs   pandas._libs.tslibsr	   pandas.core.dtypes.commonr
   r   pandas.core.commoncorecommonr   pandas.core.computation.commonr   r   pandas.core.computation.scoper   pandas.io.formats.printingr   r   
REDUCTIONS_unary_math_ops_binary_math_opsr-  rA   r*   r/   r   r   r   r   r   gtltgeleeqne_cmp_ops_funcsdictzipr  r   and_or__bool_ops_funcsr
  ARITH_OPS_SYMSaddsubmultruedivpowfloordivmod_arith_ops_funcs_arith_ops_dictSPECIAL_CASE_ARITH_OPS_SYMS_special_case_arith_ops_funcs_special_case_arith_ops_dictr   dr_   r   r   r   r  r  r  posneginvert_unary_ops_funcsr  r  r   r*  rW   r;   r:   <module>r]     su   #      )
 !   :
 
,   
,
, 	q  q ht " 3c238 38l   BKKKKKKKKKKKK	 S~67'==(,,x||Lc-9:6LLLLLLLLLL  s>+;<=/ !)x/@/@(,, O ##%BC    
	9 AA2!UNB UNp7G% G0 (LL(,,Q s>+;<=.b .b@r @ $ $r;   