
    Owg9                       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 er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jZ                  ej\                  ej^                  ej`                  ejb                  ejd                  e*e+fZ3 e4 e5e,e3            Z6dZ7ejp                  ejr                  ejp                  ejr                  fZ: e4 e5e7e:            Z;dZ<ejz                  ej|                  ej~                  ej                  ej                  ej                  ej                  fZD e4 e5e<eD            ZEd ZFej                  ej                  ej                  fZG e4 e5eFeG            ZHi ZIe6e;eEfD ]  ZJeIj                  eJ        d,d!ZL G d" d#e)      ZMd,d$ZNd%ZOej                  ej                  ej                  ej                  fZS e4 e5eOeS            ZT G d& d'e)      ZU G d( d)e)      ZV G d* d+      ZWy)-z
Operator classes for eval.
    )annotations)datetime)partialN)TYPE_CHECKINGCallableLiteral)	Timestamp)is_list_like	is_scalar)ensure_decodedresult_type_many)DEFAULT_GLOBALS)pprint_thingpprint_thing_encoded)IterableIterator)sumprodminmax)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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          R/var/www/horilla/myenv/lib/python3.12/site-packages/pandas/core/computation/ops.pyr5   zTerm.__new__L   s)     *4 53u-    boolis_localc                    || _         || _        || _        t        |      }|j	                  t
              xs |t        v | _        | j                         | _	        || _
        y r0   )_namer8   r9   r2   
startswith	LOCAL_TAGr   rA   _resolve_name_valuer:   )selfr7   r8   r9   r:   tnames         r>   __init__zTerm.__init__T   sS    
	D	((3Ou7O((* r?   c                B    | j                   j                  t        d      S )N )r7   replacerE   rH   s    r>   
local_namezTerm.local_name^   s    yy  B//r?   c                ,    t        | j                        S r0   )r   r7   rN   s    r>   __repr__zTerm.__repr__b   s    DII&&r?   c                    | j                   S r0   valuerH   argskwargss      r>   __call__zTerm.__call__e       zzr?   c                    | S r0    rU   s      r>   evaluatezTerm.evaluateh   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)rA   ndim   z?N-dimensional objects, where N > 2, are not supported with eval)r2   rO   rA   r8   scoper1   typeresolveupdatehasattrr^   NotImplementedError)rH   rO   rA   ress       r>   rF   zTerm._resolve_namek   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)r7   r1   r2   r8   swapkeyrO   rT   )rH   rT   keys      r>   rc   zTerm.update|   s=     ii c3HHT__cUC
r?   c                ,    t        | j                        S r0   )r   rG   rN   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r0   )rG   valuesdtypeAttributeErrorra   rN   s    r>   ra   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=))ra   __name__reprr7   rN   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r0   )ra   ro   
issubclassr   np
datetime64rH   ts     r>   is_datetimezTerm.is_datetime   sF    			A !h677  			A	   8 AAc                    | j                   S r0   rG   rN   s    r>   rT   z
Term.value   s    {{r?   c                    || _         y r0   r~   )rH   rh   s     r>   rT   z
Term.value   s	    r?   c                    | j                   S r0   rC   rN   s    r>   r7   z	Term.name       zzr?   c                .    | j                   j                  S r0   )rG   r^   rN   s    r>   r^   z	Term.ndim   s    {{r?   )NNreturnNoner   r2   )r   r.   r   r@   )r   int)rr   
__module____qualname__r5   __annotations__rJ   propertyrO   rQ   rX   r\   rF   rc   r   ra   return_typert   r{   rT   setterr7   r^   __classcell__r=   s   @r>   r.   r.   K   s     N! 0 0'"$ & & 
) 
) KR R 8 8   \\         r?   r.   c                  *    e Zd Zd Zed        ZddZy)r3   c                    | j                   S r0   r   rN   s    r>   rF   zConstant._resolve_name   rY   r?   c                    | j                   S r0   rS   rN   s    r>   r7   zConstant.name   r   r?   c                ,    t        | j                        S r0   )rs   r7   rN   s    r>   rQ   zConstant.__repr__   s     DIIr?   Nr   )rr   r   r   rF   r   r7   rQ   r[   r?   r>   r3   r3      s       r?   r3   ~&|)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.
    r2   opNc                V    t         j                  ||      | _        || _        || _        y r0   )_bool_op_mapgetr   operandsr:   )rH   r   r   r:   s       r>   rJ   zOp.__init__   s$    ""2r*  r?   c                ,    t        | j                        S r0   )iterr   rN   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)(rq   N)r   ).0oprs     r>   	<genexpr>zOp.__repr__.<locals>.<genexpr>   s     EQ|C()+Es    )r   r   r   join)rH   pareneds     r>   rQ   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r0   ra   r   terms     r>   r   z!Op.return_type.<locals>.<genexpr>   s     !J$))!J   )r   CMP_OPS_SYMSBOOL_OPS_SYMSrw   bool_r   comflattenrN   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	frozensetrw   rn   r   r   )rH   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r0   r   r   s     r>   r   z#Op.operand_types.<locals>.<genexpr>   s     AtAr   )r   r   r   rN   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r0   )r   )r   operands     r>   r   zOp.is_scalar.<locals>.<genexpr>   s     B7$$Br   )allr   rN   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r0   )r   ra   ro   rv   r   rw   rx   ry   s     r>   r{   zOp.is_datetime   sL    	!  %%A !h677  	!  A	!r|   r0   )r   r2   r   zIterable[Term | Op]r   r   )r   r   r   r   )rr   r   r   __doc__r   rJ   r   rQ   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.
    isinro   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        | t              S r0   )r1   r.   )objs    r>   is_termr   O  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 )r4   rJ   lhsrhs_disallow_scalar_only_bool_opsconvert_values_binary_ops_dictfuncKeyErrorlistkeys
ValueErrorrs   )rH   r   r   r   errr   r=   s         r>   rJ   zBinOp.__init__^  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   )rH   r8   leftrights       r>   rX   zBinOp.__call__p  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   )r8   )	r   r\   r   r   r   rT   pandas.core.computation.evalr   add_tmp)rH   r8   r   r   r   r   rf   r   r   r   r7   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   )rT   encoderrH   s     r>   	stringifyz'BinOp.convert_values.<locals>.stringify  s-    }}(!"6O&5>!r?   NUTC)r   r   r   r{   r   rT   r1   r   floatr	   r   tz
tz_convertrc   )rH   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 )Nra   z$cannot evaluate scalar only bool ops)r   r   r   getattrr   r   _bool_ops_dictrv   r@   rw   r   re   )rH   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   r2   r   r   )r   r2   r   )
rr   r   r   r   rJ   rX   r\   r   r   r   r   s   @r>   r   r   S  s$    $&&/(bBNr?   r   c                p    t        t        j                  |       j                  t        j                        S r0   )rv   rw   rn   ra   number)rn   s    r>   	isnumericr    s!    bhhuo**BII66r?   )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   )	r4   rJ   r   _unary_ops_dictr   r   r   rs   UNARY_OPS_SYMS)rH   r   r   r   r=   s       r>   rJ   zUnaryOp.__init__  si    gZ(	'+DI 	)$r( 4''5&68 	s   * 	AAAc                F    | j                  |      }| j                  |      S r0   )r   r   )rH   r8   r   s      r>   rX   zUnaryOp.__call__  s    ,,s#yy!!r?   c                L    t        | j                   d| j                   d      S )Nr   rq   )r   r   r   rN   s    r>   rQ   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 )Nr@   r   )	r   r   rw   rn   r1   r   r   _cmp_ops_dictr  )rH   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)
rr   r   r   r   rJ   rX   rQ   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 r0   )r4   rJ   r7   r   )rH   r   rV   r=   s      r>   rJ   zMathCall.__init__&  s    D)	r?   c                |    | j                   D cg c]
  } ||       }} | j                  j                  | S c c}w r0   )r   r   )rH   r8   r   r   s       r>   rX   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   ,rq   )mapr2   r   r   r   r   )rH   r   s     r>   rQ   zMathCall.__repr__/  s8    sDMM*twwiq();(<A>??r?   r   r   )rr   r   r   rJ   rX   rQ   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   r7   r  rw   r   )rH   r7   s     r>   rJ   zFuncNode.__init__5  s4    wq&CDEE	B%	r?   c                    t        | |      S r0   )r  )rH   rV   s     r>   rX   zFuncNode.__call__;  s    d##r?   N)r7   r2   r   r   r  )rr   r   r   rJ   rX   r[   r?   r>   r  r  4  s    &$r?   r  r   )Xr   
__future__r   r   	functoolsr   operatortypingr   r   r   numpyrw   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   
REDUCTIONS_unary_math_ops_binary_math_opsr!  rE   r.   r3   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   drc   r   r   r  r  posneginvert_unary_ops_funcsr  r  r  r  r[   r?   r>   <module>rR     sl   #      )
 !   :
 
 +
,   
,
, 	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!UNB UNp7 (LL(,,Q s>+;<=.b .b@r @$ $r?   