
    i8                    @   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	 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 er
ddlmZ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jZ                  ej\                  ej^                  ej`                  ejb                  ejd                  e*e+fZ3 e4 e5e,e3d            Z6d Z7ejp                  ejr                  ejp                  ejr                  fZ: e4 e5e7e:d            Z;d!Z<ejz                  ej|                  ej~                  ej                  ej                  ej                  ej                  fZD e4 e5e<eDd            ZEi ZFe6e;eEfD ]  ZGeFj                  eG        d,d"ZI G d# d$e)      ZJd%ZKej                  ej                  ej                  ej                  fZO e4 e5eKeOd            ZP G d& d'e)      ZQ G d( d)e)      ZR G d* d+      ZSy)-z
Operator classes for eval.
    )annotations)datetime)partialN)TYPE_CHECKINGLiteral)	Timestamp)is_list_like	is_scalar)ensure_decodedresult_type_many)DEFAULT_GLOBALS)pprint_thingpprint_thing_encoded)CallableIterableIterator)sumprodminmax)sincostan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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          X/app/cer_product_mecsu/.venv/lib/python3.12/site-packages/pandas/core/computation/ops.pyr6   zTerm.__new__M   s)     *4 53u-    boolis_localc                    || _         || _        || _        t        |      }|j	                  t
              xs |t        v | _        | j                         | _	        || _
        y r1   )_namer9   r:   r3   
startswith	LOCAL_TAGr   rB   _resolve_name_valuer;   )selfr8   r9   r:   r;   tnames         r?   __init__zTerm.__init__T   sS    
	D	((3Ou7O((* r@   c                B    | j                   j                  t        d      S )N )r8   replacerF   rI   s    r?   
local_namezTerm.local_name^   s    yy  B//r@   c                ,    t        | j                        S r1   )r   r8   rO   s    r?   __repr__zTerm.__repr__b   s    DII&&r@   c                    | j                   S r1   valuerI   argskwargss      r?   __call__zTerm.__call__e       zzr@   c                    | S r1    rV   s      r?   evaluatezTerm.evaluateh   s    r@   c                   t        | j                        }| j                  }|| j                  j                  v r)t        | j                  j                  |   t              rd}| j                  j                  ||      }| j                  |       t        |d      r4t        |j                  t              r|j                  dkD  rt        d      |S )NF)rB   ndim   z?N-dimensional objects, where N > 2, are not supported with eval)r3   rP   rB   r9   scoper2   typeresolveupdatehasattrr_   intNotImplementedError)rI   rP   rB   ress       r?   rG   zTerm._resolve_namek   s    )
=='JHHNN:&-
 HhhzH=C3Jsxx$=#((Q,%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)r8   r2   r3   r9   swapkeyrP   rU   )rI   rU   keys      r?   rd   zTerm.update|   s=     ii c3HHT__cUC
r@   c                ,    t        | j                        S r1   )r
   rH   rO   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r1   )rH   valuesdtypeAttributeErrorrb   rO   s    r?   rb   z	Term.type   s_    		);;%%+++ 	)){{(((! )DKK(()		)s,   " 	A+AA+A'"A+&A''A+c                f    t        |       j                   d| j                  d| j                    dS )Nz(name=z, type=))rb   __name__r8   rO   s    r?   rawzTerm.raw   s.    t*%%&fTYYM1MMr@   c                    	 | j                   j                   }t        |t        t        j
                  f      S # t        $ r | j                   }Y 7w xY wr1   )rb   rq   
issubclassr   np
datetime64rI   ts     r?   is_datetimezTerm.is_datetime   sF    			A !h677  			A	   8 AAc                    | j                   S r1   rH   rO   s    r?   rU   z
Term.value   s    {{r@   c                    || _         y r1   r   )rI   rj   s     r?   rU   z
Term.value   s	    r@   c                    | j                   S r1   rD   rO   s    r?   r8   z	Term.name       zzr@   c                .    | j                   j                  S r1   )rH   r_   rO   s    r?   r_   z	Term.ndim   s    {{r@   )NNreturnNoner   r3   )r   r/   r   rA   )r   rf   )rt   
__module____qualname__r6   __annotations__rK   propertyrP   rR   rY   r]   rG   rd   r
   rb   return_typeru   r|   rU   setterr8   r_   __classcell__r>   s   @r?   r/   r/   L   s    
 N! 0 0'"$ & & 
) 
) KN N 8 8   \\         r@   r/   c                  *    e Zd Zd Zed        ZddZy)r4   c                    | j                   S r1   r   rO   s    r?   rG   zConstant._resolve_name   rZ   r@   c                    | j                   S r1   rT   rO   s    r?   r8   zConstant.name   r   r@   c                ,    t        | j                        S r1   )reprr8   rO   s    r?   rR   zConstant.__repr__   s     DIIr@   Nr   )rt   r   r   rG   r   r8   rR   r\   r@   r?   r4   r4      s       r@   r4   ~&|)notandorc                      e Zd ZU dZded<   dddZd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.
    r3   opNc                V    t         j                  ||      | _        || _        || _        y r1   )_bool_op_mapgetr   operandsr;   )rI   r   r   r;   s       r?   rK   zOp.__init__   s$    ""2r*  r@   c                ,    t        | j                        S r1   )iterr   rO   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)(rs   N)r   ).0oprs     r?   	<genexpr>zOp.__repr__.<locals>.<genexpr>   s     EQ|C()+Es    )r   r   r   join)rI   pareneds     r?   rR   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r1   rb   r   terms     r?   r   z!Op.return_type.<locals>.<genexpr>   s     !J$))!J   )r   CMP_OPS_SYMSBOOL_OPS_SYMSrx   bool_r   comflattenrO   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	frozensetrx   rp   r   r   )rI   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r1   r   r   s     r?   r   z#Op.operand_types.<locals>.<genexpr>   s     AtAr   )r   r   r   rO   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r1   )r
   )r   operands     r?   r   zOp.is_scalar.<locals>.<genexpr>   s     B7$$Br   )allr   rO   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r1   )r   rb   rq   rw   r   rx   ry   rz   s     r?   r|   zOp.is_datetime   sL    	!  %%A !h677  	!  A	!r}   r1   )r   r3   r   zIterable[Term | Op]r   r   )r   r   r   r   )rt   r   r   __doc__r   rK   r   rR   r   r   r   r   r
   r|   r\   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.
    isinrq   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 inT)strict)r   r   r   r   )+-*/z**z//%c                "    t        | t              S r1   )r2   r/   )objs    r?   is_termr   I  s    c4  r@   c                  B     e Zd ZdZd fdZd ZddZd	dZd	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                $   t         |   |||f       || _        || _        | j	                          | j                          	 t        |   | _        y # t        $ r4}t        t        j                               }t        d|d|       |d }~ww xY w)NzInvalid binary operator , valid operators are )r5   rK   lhsrhs_disallow_scalar_only_bool_opsconvert_values_binary_ops_dictfuncKeyErrorlistkeys
ValueError)rI   r   r   r   errr   r>   s         r?   rK   zBinOp.__init__X  s    c3Z(++-	(,DI 	(--/0D*2&0FtfM	s   A 	B/B

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   )rI   r9   leftrights       r?   rY   zBinOp.__call__j  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   )r9   )	r   r]   r   r   r   rU   pandas.core.computation.evalr   add_tmp)rI   r9   r   r   r   r   rh   r   r   r   r8   s              r?   r]   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)r;   )r;   r   r   r   )rU   encoderrI   s     r?   	stringifyz'BinOp.convert_values.<locals>.stringify  s-    }}(!"6O&5>!r@   NUTC)r   r   r   r|   r
   rU   r2   rf   floatr   r   tz
tz_convertrd   )rI   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 )Nrb   z$cannot evaluate scalar only bool ops)r   r   r   getattrr
   r   _bool_ops_dictrw   rA   rx   r   rg   )rI   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   r3   r   r   )r   r3   r   )
rt   r   r   r   rK   rY   r]   r   r   r   r   s   @r?   r   r   M  s$    $&&/(bBN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|dt               |d }~ww xY w)NzInvalid unary operator r   )r5   rK   r   _unary_ops_dictr   r   r   UNARY_OPS_SYMS)rI   r   r   r   r>   s       r?   rK   zUnaryOp.__init__  s^    gZ(	'+DI 	)"/EnEUV	s   * 	AA		Ac                F    | j                  |      }| j                  |      S r1   )r   r   )rI   r9   r   s      r?   rY   zUnaryOp.__call__  s    ,,s#yy!!r@   c                L    t        | j                   d| j                   d      S )Nr   rs   )r   r   r   rO   s    r?   rR   zUnaryOp.__repr__  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 )NrA   rf   )	r   r   rx   rp   r2   r   r   _cmp_ops_dictr  )rI   r   s     r?   r   zUnaryOp.return_type  so    ,,"((6"2288F##gr"JJ-'7::+G88F##xxr@   )r   zLiteral['+', '-', '~', 'not']r   r   r   MathCallr   )r   znp.dtype)
rt   r   r   r   rK   rY   rR   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 r1   )r5   rK   r8   r   )rI   r   rW   r>   s      r?   rK   zMathCall.__init__  s    D)	r@   c                |    | j                   D cg c]
  } ||       }} | j                  j                  | S c c}w r1   )r   r   )rI   r9   r   r   s       r?   rY   zMathCall.__call__  s7    &*mm4BsG44tyy~~x(( 5s   9c                    t        t        | j                        }t        | j                   ddj                  |       d      S )Nr   ,rs   )mapr3   r   r   r   r   )rI   r   s     r?   rR   zMathCall.__repr__$  s8    sDMM*twwiq();(<A>??r@   r   r   )rt   r   r   rK   rY   rR   r   r   s   @r?   r  r    s    )
@r@   r  c                      e Zd ZddZddZy)FuncNodec                j    |t         vrt        d| d      || _        t        t        |      | _        y )N"z" is not a supported function)MATHOPSr   r8   r  rx   r   )rI   r8   s     r?   rK   zFuncNode.__init__*  s4    wq&CDEE	B%	r@   c                    t        | |      S r1   )r  )rI   rW   s     r?   rY   zFuncNode.__call__0  s    d##r@   N)r8   r3   r   r   r  )rt   r   r   rK   rY   r\   r@   r?   r  r  )  s    &$r@   r  r   )Tr   
__future__r   r   	functoolsr   operatortypingr   r   numpyrx   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   collections.abcr   r   r   
REDUCTIONS_unary_math_ops_binary_math_opsr  rF   r/   r4   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_dictr   drd   r   r   r  posneginvert_unary_ops_funcsr  r
  r  r  r\   r@   r?   <module>rL     s5   #   
  )
 !   :
   +
.   
,
, 	p  p ft  3c238 38l   BKKKKKKKKKKKK	 S~dCD'==(,,x||Lc-FG6LLLLLLLLLL  s>+;DIJ 
	9 AA!UNB UNp (LL(,,Q s>+;DIJ-b -`@r @$ $r@   