
    Eg,?                    @   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j-        ej.        ej/        ej0        ej1        ej2        e*e+fZ3 e4 e5e,e3                    Z6dZ7ej8        ej9        ej8        ej9        fZ: e4 e5e7e:                    Z;dZ<ej=        ej>        ej?        ej@        ejA        ejB        ejC        fZD e4 e5e<eD                    ZEd ZFejA        ejB        ejC        fZG e4 e5eFeG                    ZHi ZIe6e;eEfD ]ZJeIK                    eJ           d2d#ZLd3d%ZM G d& d'e)          ZNd3d(ZO G d) d*eN          ZPd+ZQejR        ejS        ejT        ejT        fZU e4 e5eQeU                    ZV G d, d-e)          ZW G d. d/e)          ZX G d0 d1          ZYdS )4z
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 )TermNc                    t          |t                    st          n| }t          t          |          j        } ||          S N)
isinstancestrConstantsuperr.   __new__)clsnameenvsideencodingklasssupr_new	__class__s          P/var/www/sysmax/venv/lib/python3.11/site-packages/pandas/core/computation/ops.pyr5   zTerm.__new__L   s;     *4 5 5>3u%%-x    boolis_localreturnNonec                    || _         || _        || _        t          |          }|                    t
                    p|t          v | _        |                                 | _	        || _
        d S r0   )_namer8   r9   r2   
startswith	LOCAL_TAGr   rA   _resolve_name_valuer:   )selfr7   r8   r9   r:   tnames         r>   __init__zTerm.__init__T   s_    
	D		((33Ou7O((** r?   r2   c                B    | j                             t          d          S )N )r7   replacerG   rJ   s    r>   
local_namezTerm.local_name^   s    y  B///r?   c                *    t          | j                  S r0   )r   r7   rP   s    r>   __repr__zTerm.__repr__b   s    DI&&&r?   c                    | j         S r0   valuerJ   argskwargss      r>   __call__zTerm.__call__e   
    zr?   c                    | S r0    rW   s      r>   evaluatezTerm.evaluateh   s    r?   c                \   t          | j                  }| j        }|| j        j        v r't          | j        j        |         t                    rd}| j                            ||          }|                     |           t          |d          r|j
        dk    rt          d          |S )NF)rA   ndim   z?N-dimensional objects, where N > 2, are not supported with eval)r2   rQ   rA   r8   scoper1   typeresolveupdatehasattrr`   NotImplementedError)rJ   rQ   rA   ress       r>   rH   zTerm._resolve_namek   s    ))
=''JHN:&-
 -
' HhzH==C3 	CHqLL%Q   
r?   c                    | j         }t          |t                    r"| j                            | j        ||           || _        dS )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   swapkeyrQ   rV   )rJ   rV   keys      r>   re   zTerm.update|   sJ     i c3 	DHT_cUCCC


r?   c                *    t          | j                  S r0   )r   rI   rP   s    r>   r   zTerm.is_scalar   s    %%%r?   c                    	 | j         j        j        S # t          $ r6 	 | j         j        cY S # t          $ r t	          | j                   cY cY S w xY ww xY wr0   )rI   valuesdtypeAttributeErrorrc   rP   s    r>   rc   z	Term.type   s}    		);%++ 	) 	) 	)){((((! ) ) )DK((((((()		)s)    
A,AA
AAAc                j    t          |           j         dt          | j                   d| j          dS )Nz(name=z, type=))rc   __name__reprr7   rP   s    r>   rawzTerm.raw   s4    t**%QQT$)__QQTYQQQQr?   c                    	 | j         j         }n# t          $ r
 | j         }Y nw xY wt          |t          t          j        f          S r0   )rc   rq   
issubclassr   np
datetime64rJ   ts     r>   is_datetimezTerm.is_datetime   sQ    		AA 	 	 		AAA	 !h6777    ##c                    | j         S r0   rI   rP   s    r>   rV   z
Term.value   s
    {r?   c                    || _         d S r0   r   )rJ   rj   s     r>   rV   z
Term.value   s    r?   c                    | j         S r0   rE   rP   s    r>   r7   z	Term.name   
    zr?   intc                    | j         j        S r0   )rI   r`   rP   s    r>   r`   z	Term.ndim   s    {r?   )NNrB   rC   rB   r2   )rB   r.   rB   r@   )rB   r   )rt   
__module____qualname__r5   __annotations__rL   propertyrQ   rS   rZ   r^   rH   re   r   rc   return_typerv   r}   rV   setterr7   r`   __classcell__r=   s   @r>   r.   r.   K   s              NNN! ! ! ! ! 0 0 0 X0' ' ' '       "   $ & & & X& 
) 
) X
) KR R R XR 8 8 8 X8   X \      \    X       X         r?   r.   c                  2    e Zd Zd Zed             ZddZdS )r3   c                    | j         S r0   r   rP   s    r>   rH   zConstant._resolve_name   r[   r?   c                    | j         S r0   rU   rP   s    r>   r7   zConstant.name   r   r?   rB   r2   c                *    t          | j                  S r0   )ru   r7   rP   s    r>   rS   zConstant.__repr__   s     DIr?   Nr   )rt   r   r   rH   r   r7   rS   r]   r?   r>   r3   r3      sR             X     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dS )Opz.
    Hold an operator of arbitrary arity.
    r2   opNoperandsIterable[Term | Op]rB   rC   c                b    t                               ||          | _        || _        || _        d S r0   )_bool_op_mapgetr   r   r:   )rJ   r   r   r:   s       r>   rL   zOp.__init__   s+    ""2r**  r?   r   c                *    t          | j                  S r0   )iterr   rP   s    r>   __iter__zOp.__iter__   s    DM"""r?   c                z    d | j         D             }t          d| j         d                    |                    S )zW
        Print a generic n-ary operator and its operands using infix notation.
        c              3  <   K   | ]}d t          |           dV  dS )(rs   N)r   ).0oprs     r>   	<genexpr>zOp.__repr__.<locals>.<genexpr>   s6      EE+|C((+++EEEEEEr?    )r   r   r   join)rJ   pareneds     r>   rS   zOp.__repr__   s@    
 FEt}EEENNNN//88999r?   c                    | j         t          t          z   v rt          j        S t          d t          j        |           D              S )Nc              3  $   K   | ]}|j         V  d S r0   rc   r   terms     r>   r   z!Op.return_type.<locals>.<genexpr>   s$      !J!J$)!J!J!J!J!J!Jr?   )r   CMP_OPS_SYMSBOOL_OPS_SYMSry   bool_r   comflattenrP   s    r>   r   zOp.return_type   sA     7|m3448O!J!JD8I8I!J!J!JKKr?   r@   c                ~    | j         }t          t          j        d          g          }| j        t
          k    o||z
  S )Nobject)operand_types	frozensetry   rp   r   r   )rJ   typesobj_dtype_sets      r>   has_invalid_return_typezOp.has_invalid_return_type   s<    "!28H#5#5"6776)Cem.CCr?   c                X    t          d t          j        |           D                       S )Nc              3  $   K   | ]}|j         V  d S r0   r   r   s     r>   r   z#Op.operand_types.<locals>.<genexpr>   s$      AAtAAAAAAr?   )r   r   r   rP   s    r>   r   zOp.operand_types   s)    AAs{4/@/@AAAAAAr?   c                >    t          d | j        D                       S )Nc              3  $   K   | ]}|j         V  d S r0   )r   )r   operands     r>   r   zOp.is_scalar.<locals>.<genexpr>   s%      BB7$BBBBBBr?   )allr   rP   s    r>   r   zOp.is_scalar   s!    BBDMBBBBBBr?   c                    	 | j         j        }n# t          $ r
 | j         }Y nw xY wt          |t          t
          j        f          S r0   )r   rc   rq   rx   r   ry   rz   r{   s     r>   r}   zOp.is_datetime   sT    	! %AA 	! 	! 	! AAA	! !h6777r~   r0   )r   r2   r   r   rB   rC   )rB   r   r   r   )rt   r   r   __doc__r   rL   r   rS   r   r   r   r   r   r}   r]   r?   r>   r   r      s          GGG! ! ! ! !
# # # #: : : : L L XL D D D XD
 B B XB C C C XC 8 8 8 X8 8 8r?   r   c                    	 |                      |          S # t          $ r> t          |           r(	 |                     |           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     s    
vvayy   ?? 	vvayy   !   Avs2    AAA
AAAAAc                    	 |                      |           S # t          $ r? t          |           r)	 |                     |            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s2    A!A
A!

AA!AA! A!)><z>=z<=z==z!=inznot in)r   r   r   r   )+-*/**//%)r   r   r   rB   rC   c                   t          j        |          }| D ]g}|j        |v r	 |j                            |          }n*# t
          $ r |                    |j                  }Y nw xY w|                    |           hdS )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)ry   rp   rc   rV   astyperq   re   )termsacceptable_dtypesrp   dtr   rj   s         r>   _cast_inplacer   O  s     
%B  9)))	,
))"--II 	, 	, 	,
++III	,I s   ?$A&%A&r@   c                ,    t          | t                    S r0   )r1   r.   )objs    r>   is_termr   h  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
    r   r2   rB   rC   c                   t                                          |||f           || _        || _        |                                  |                                  	 t          |         | _        d S # t          $ rN}t          t          
                                          }t          dt          |           d|           |d }~ww xY w)NzInvalid binary operator , valid operators are )r4   rL   lhsrhs_disallow_scalar_only_bool_opsconvert_values_binary_ops_dictfuncKeyErrorlistkeys
ValueErrorru   )rJ   r   r   r   errr   r=   s         r>   rL   zBinOp.__init__w  s    c3Z(((++---	(,DIII 	 	 	(--//00DQ488QQ4QQ 	s   A1 1
C	;A	CC	c                    |                      |          }|                     |          }|                     ||          S )z
        Recursively evaluate an expression in Python space.

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

        Returns
        -------
        object
            The result of an evaluated expression.
        )r   r   r   )rJ   r8   leftrights       r>   rZ   zBinOp.__call__  s6     xx}}yyu%%%r?   enginec                d   |dk    r | |          }n}| j                             |||||          }| j                            |||||          }| j        |v r!|                     |j        |j                  }nddlm}	  |	| |||          }|                    |          }
 ||
|          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)r   parser	term_typeeval_in_pythonr   )eval)
local_dictr   r   )r8   )	r   r^   r   r   r   rV   pandas.core.computation.evalr   add_tmp)rJ   r8   r   r   r   r   rh   r   r   r   r7   s              r>   r^   zBinOp.evaluate  s    " X$s))CC 8$$#- %  D H%%#- &  E w.((ii
EK88======d4CvNNN{{3y3''''r?   c                     fd} j          j        }}t          |          r|j        rt          |          r|j        r|j        }t          |t          t          f          r ||          }t          t          |                    }|j        |                    d          } j                            |           t          |          r|j        rt          |          r|j        r|j        }t          |t          t          f          r ||          }t          t          |                    }|j        |                    d          } j                             |           dS dS dS dS dS )zK
        Convert datetimes to a comparable value in an expression.
        c                n    j         t          t          j                   }nt          } ||           S )N)r:   )r:   r   r   r   )rV   encoderrJ   s     r>   	stringifyz'BinOp.convert_values.<locals>.stringify  s5    }(!"6OOO&75>>!r?   NUTC)r   r   r   r}   r   rV   r1   r   floatr	   r   tz
tz_convertre   )rJ   r  r   r   vs   `    r>   r   zBinOp.convert_values  s   
	" 	" 	" 	" 	" 8TXS3<< 	CO 	 	 		A!c5\** !IaLL.++,,AtLL''HOOA3<< 	CO 	 	 		A!c5\** !IaLL.++,,AtLL''HOOA	 	 	 	 	 	 	 	r?   c                d   | j         }| j        }|j        }t          |d|          }|j        }t          |d|          }|j        s|j        ra| j        t          v rQt          |t          t          j
        f          r!t          |t          t          j
        f          st          d          d S d S d S )Nrc   z$cannot evaluate scalar only bool ops)r   r   r   getattrr   r   _bool_ops_dictrx   r@   ry   r   rg   )rJ   r   r   rhs_rtlhs_rts        r>   r   z$BinOp._disallow_scalar_only_bool_ops  s    hh 0000]
	N!m
	N>)) vbh'788 * #6D"(+;<<	 * &&LMMM *)
	N 
	N))r?   )r   r2   rB   rC   )r   r2   r   )
rt   r   r   r   rL   rZ   r^   r   r   r   r   s   @r>   r   r   l  s              $& & &&/( /( /( /(b   BN N N N N N Nr?   r   c                d    t          t          j        |           j        t          j                  S r0   )rx   ry   rp   rc   number)rp   s    r>   	isnumericr    s    bhuoo*BI6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.
    rB   rC   c           	     x   t                                          d||           t          |j                  rt          |j                  s(t	          d| j         d|j         d|j         d          t          j        t          j        g}t          t          j        |           |t          j                   d S )Nr   z unsupported operand type(s) for z: 'z' and '')r4   rL   r  r   	TypeErrorr   ry   float32float64r   r   r   )rJ   r   r   r   r=   s       r>   rL   zDiv.__init__  s    c3''')) 	3?1K1K 	?47 ? ?O? ?,/O? ? ?    Z4ck$''):BJGGGGGr?   r   )rt   r   r   r   rL   r   r   s   @r>   r  r    sQ         H H H H H H H H H Hr?   r  )r   r   r   r   c                  L     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.
    r   Literal['+', '-', '~', 'not']rB   rC   c                    t                                          ||f           || _        	 t          |         | _        d S # t
          $ r-}t          dt          |           dt                     |d }~ww xY w)NzInvalid unary operator r   )	r4   rL   r   _unary_ops_dictr   r   r   ru   UNARY_OPS_SYMS)rJ   r   r   r   r=   s       r>   rL   zUnaryOp.__init__6  s    gZ(((	'+DIII 	 	 	8$r(( 8 8'58 8  	s   A 
A8(A33A8MathCallc                V    |                      |          }|                     |          S r0   )r   r   )rJ   r8   r   s      r>   rZ   zUnaryOp.__call__B  s%    ,,s##yy!!!r?   r2   c                @    t          | j         d| j         d          S )Nr   rs   )r   r   r   rP   s    r>   rS   zUnaryOp.__repr__G  s%    tw88888999r?   np.dtypec                $   | j         }|j        t          j        d          k    rt          j        d          S t	          |t
                    r0|j        t          v s|j        t          v rt          j        d          S t          j        d          S )Nr@   r   )	r   r   ry   rp   r1   r   r   _cmp_ops_dictr  )rJ   r   s     r>   r   zUnaryOp.return_typeJ  sz    ,"(6"2"2228F###gr"" 	$J-''7:+G+G8F###xr?   )r   r  rB   rC   rB   r  r   )rB   r"  )
rt   r   r   r   rL   rZ   rS   r   r   r   r   s   @r>   r  r  %  s          
 
 
 
 
 
" " " "
: : : :    X    r?   r  c                  .     e Zd Zd fdZd ZddZ xZS )	r  rB   rC   c                d    t                                          |j        |           || _        d S r0   )r4   rL   r7   r   )rJ   r   rX   r=   s      r>   rL   zMathCall.__init__W  s*    D)))			r?   c                H    fd| j         D             } | j        j        | S )Nc                &    g | ]} |          S r]   r]   )r   r   r8   s     r>   
<listcomp>z%MathCall.__call__.<locals>.<listcomp>]  s!    444BBsGG444r?   )r   r   )rJ   r8   r   s    ` r>   rZ   zMathCall.__call__[  s/    4444dm444ty~x((r?   r2   c                    t          t          | j                  }t          | j         dd                    |           d          S )Nr   ,rs   )mapr2   r   r   r   r   )rJ   r   s     r>   rS   zMathCall.__repr__`  s@    sDM**tw>>(););>>>???r?   r   r   )rt   r   r   rL   rZ   rS   r   r   s   @r>   r  r  V  sh             ) ) )
@ @ @ @ @ @ @ @r?   r  c                      e Zd Zd	dZd
dZdS )FuncNoder7   r2   rB   rC   c                    |t           vrt          d| d          || _        t          t          |          | _        d S )N"z" is not a supported function)MATHOPSr   r7   r  ry   r   )rJ   r7   s     r>   rL   zFuncNode.__init__f  sC    wDDDDEEE	B%%			r?   r  c                "    t          | |          S r0   )r  )rJ   rX   s     r>   rZ   zFuncNode.__call__l  s    d###r?   N)r7   r2   rB   rC   r%  )rt   r   r   rL   rZ   r]   r?   r>   r/  r/  e  s<        & & & &$ $ $ $ $ $r?   r/  r   r   )Zr   
__future__r   r   	functoolsr   operatortypingr   r   r   numpyry   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_opsr2  rG   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   dre   r   r   r   r  r  r  posneginvert_unary_ops_funcsr  r  r  r/  r]   r?   r>   <module>rc     s    # " " " " "                           ) ) ) ) ) )       
 !                        : 9 9 9 9 9       
         
 +
,   
,
, 	q  q  q  q  q  q  q  q h    t    3c2238 38 38 38 38 38 38 38l       BKKKKKK	 SS~6677'=(,x|Lcc-99::6LLLLL  $ss>+;<<==/ !)x/@(, O #tC#%BCC      
	9  AA   2! ! ! !UN UN UN UN UNB UN UN UNp7 7 7 7H H H H H% H H H0 (L(,Q $ss>+;<<==. . . . .b . . .b@ @ @ @ @r @ @ @$ $ $ $ $ $ $ $ $ $r?   