
    i4T                       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	m
Z
mZ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Z dd
lmZ ddlmc mZ ddlmZm Z m!Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z.m/Z/ e
rddl0m1Z1m2Z2  G d de"jf                        Z4 G d de jj                        Z5 G d de5      Z6 G d de jn                        Z7 G d de7      Z8 G d de8      Z9 G d d e7      Z: G d! d"e:      Z; G d# d$e jx                        Z< G d% d&e&      Z=d' Z> G d( d)ej~                        Z@ G d* d+      ZAd-d,ZBy).z/manage PyTables query interface via Expressions    )annotationsN)DecimalInvalidOperation)partial)TYPE_CHECKINGAnyClassVarSelfcast)lib)	Timedelta	Timestamp)UndefinedVariableError)is_list_like)expropsscope)ensure_decoded)BaseExprVisitor)is_term)extract_array)Index)pprint_thingpprint_thing_encoded)TimeUnitnptc                  B     e Zd ZU dZded<   	 	 	 d	 	 	 	 	 d fdZ xZS )PyTablesScope)
queryablesdict[str, Any]r   c                F    t         |   |dz   ||       |xs i | _        y )N   )global_dict
local_dict)super__init__r   )selflevelr#   r$   r   	__class__s        ]/app/cer_product_mecsu/.venv/lib/python3.12/site-packages/pandas/core/computation/pytables.pyr&   zPyTablesScope.__init__;   s)     	
S$*    )NNN)r(   intr   dict[str, Any] | NonereturnNone)__name__
__module____qualname__	__slots____annotations__r&   __classcell__r)   s   @r*   r   r   6   s?    I
 ,0++
 *+ 
+ +r+   r   c                  L     e Zd ZU ded<   ddZdd fdZd Zed        Z xZ	S )	Termr   envc                ^    t        |t              r| }nt        }t        j	                  |      S N)
isinstancestrConstantobject__new__)clsnamer9   sideencodingklasss         r*   r@   zTerm.__new__I   s%    dC EE~~e$$r+   c                ,    t         |   ||||       y N)rC   rD   )r%   r&   r'   rB   r9   rC   rD   r)   s        r*   r&   zTerm.__init__P   s    sAr+   c                4   | j                   dk(  rG| j                  | j                  j                  vrt	        d| j                  d      | j                  S 	 | j                  j                  | j                  d      S # t        $ r | j                  cY S w xY w)Nleftzname z is not definedF)is_local)rC   rB   r9   r   	NameErrorresolver   r'   s    r*   _resolve_namezTerm._resolve_nameS   s    99yy 3 33%		}O DEE99	88##DII#>>% 	99	s   &A? ?BBc                    | j                   S r;   )_valuerN   s    r*   valuez
Term.valueb   s    {{r+   NNr9   r   r.   r/   )
r0   r1   r2   r4   r@   r&   rO   propertyrR   r5   r6   s   @r*   r8   r8   F   s-    	%B  r+   r8   c                  (     e Zd Zdd fdZd Z xZS )r>   c                l    t        |t              sJ t        |             t        |   ||||       y rG   )r<   r   typer%   r&   rH   s        r*   r&   zConstant.__init__h   s2    #}-8tCy8-sAr+   c                    | j                   S r;   )_namerN   s    r*   rO   zConstant._resolve_namel   s    zzr+   rS   rT   )r0   r1   r2   r&   rO   r5   r6   s   @r*   r>   r>   g   s    Br+   r>   c                       e Zd ZU dZded<   ded<   ded<   d fdZdd	Zd
 Zd Ze	dd       Z
e	dd       Ze	d        Ze	d        Ze	d        ZddZddZddZ xZS )BinOp   r=   opr    r   z
str | None	conditionc                R    t         |   |||       || _        || _        d | _        y r;   )r%   r&   r   rD   r_   )r'   r^   lhsrhsr   rD   r)   s         r*   r&   zBinOp.__init__w   s)    S#&$ r+   c                     y r;    rN   s    r*   _disallow_scalar_only_bool_opsz$BinOp._disallow_scalar_only_bool_ops}       r+   c                     fd} j                    j                  }}t        |      r*t        |      r ||j                  |j                        }|S t        |      s/t        |      r$ ||j	                        |j                        }|S t        |      r/t        |      s$ ||j                  |j	                              }|S t        |      s2t        |      s' ||j	                        |j	                              }S )Nc                   | |S || S }t        | t              r3t        |t              rt        }n_t        | |      r| S t        ||      rE|S t        | t              r3t        |t              rt        }nt        | |      r| S t        ||      r|S  |j
                  | |j                  j                        j                         S )z5create and return a new specialized BinOp from myself)r   rD   )	r<   ConditionBinOpJointConditionBinOpFilterBinOpJointFilterBinOpr^   r   rD   evaluate)rJ   rightkrE   r'   s      r*   przBinOp.prune.<locals>.pr   s    |A$/e^4+Aa(Kq) LD+.e[1(Aa(Kq) Lu4==hjr+   )ra   rb   r   rR   prune)r'   rE   rp   rJ   rn   ress   ``    r*   rq   zBinOp.prune   s    	8 hhe4=WU^TZZ-C 
 75>TZZ&4C 
 T]75>TZZU!34C 
 $-75>TZZ&E(:;C
r+   c                v    t        |      s|g}t        |t        j                        r|j	                         }|S )zinplace conform rhs)r   r<   npndarrayravel)r'   rb   s     r*   conformzBinOp.conform   s/    C %Cc2::&))+C
r+   c                2    | j                   | j                  v S )z$return True if this is a valid field)ra   r   rN   s    r*   is_validzBinOp.is_valid   s     xx4??**r+   c                P    | j                   j                  | j                        duS )zx
        return True if this is a valid column name for generation (e.g. an
        actual column in the table)
        N)r   getra   rN   s    r*   is_in_tablezBinOp.is_in_table   s"     ""488,D88r+   c                b    t        | j                  j                  | j                        dd      S )zthe kind of my fieldkindNgetattrr   r{   ra   rN   s    r*   r~   z
BinOp.kind   &     t**4884fdCCr+   c                b    t        | j                  j                  | j                        dd      S )zthe meta of my fieldmetaNr   rN   s    r*   r   z
BinOp.meta   r   r+   c                b    t        | j                  j                  | j                        dd      S )zthe metadata of my fieldmetadataNr   rN   s    r*   r   zBinOp.metadata   s&     t**4884j$GGr+   c                x    |j                  | j                        }d| j                   d| j                   d| dS )z2create and return the op string for this TermValue( ))tostringrD   ra   r^   )r'   vvals      r*   generatezBinOp.generate   s7    jj'488*AdggYauA..r+   c           	          fd}t         j                        }t         j                        }|dk(  s|r|j                  d      rt	        |t
        t        f      r ||      }t        |      }d}d|v r!t        d|j                  d      d   dd       }t        |      j                  |      }|j                  |j                  d	      }t        ||j                  |      S |j                  d
      rd}d|v r!t        d|j                  d      d   dd       }t	        |t              rt!        |      }nCt#        j$                  |      st#        j&                  |      rt!        |d      }nt!        |      }|j                  |      j                  }t        t        |      ||      S |dk(  rFt)         j*                  d      }||vrd}nt-        j.                  ||k(        d   }t        ||d      S |dk(  r4	 t1        |      }t        |j3                  d            }t        |||      S |dk(  rt        |      }t        |||      S |dk(  rIt	        |t              r!|j7                         j9                         dv}nt;        |      }t        |||      S t	        |t              rt        | ||      d      S t=        d| dt?        |       d| d      # t4        $ r t        |       Y w xY w)zn
        convert the expression that is in the term to something that is
        accepted by pytables
        c                `    j                   t        | j                         S t        |       S )N)rD   )rD   r   r   )rR   r'   s    r*   	stringifyz&BinOp.convert_value.<locals>.stringify   s)    }}(+EDMMJJ&&r+   datetime
datetime64ns[r   NUTC	timedeltas)unitcategoryT)extract_numpyr   integerROUND_HALF_EVEN)roundingfloatbool)	falsefnonnone0z[]z{} stringzCannot compare z	 of type z to z column) r   r~   r   
startswithr<   r,   r   r   splitr   as_unittz
tz_convert	TermValuerQ   r=   r   r   
is_integeris_floatr   r   rt   flatnonzeror   to_integral_exactr   striplowerr   	TypeErrorrX   )	r'   conv_valr   r~   r   r   r   resultv_decs	   `        r*   convert_valuezBinOp.convert_value   s   	'
 dii(dii(:$4??<+H(S%L1$X.%h/H!Dd{J

3(;CR(@A *2248H{{&#..u5Xx==__[)Dd{J

3(;CR(@A(C($X.)S\\(-C$XC8$X.''-44HS]Hd;;Z$T]]$GHx' H(<=a@VVY77YT) u66@Q6RSXx66W_XHXx66V^(C(#>>+113 
< 
  >Xx66#&Xy':HEE!(9T(^4DDgV = $   h s    K K65K6c                     y r;   rd   rN   s    r*   convert_valueszBinOp.convert_values&  rf   r+   )r^   r=   r   r    r.   r/   r.   r/   r.   r   r.   r=   )r.   r   )r0   r1   r2   _max_selectorsr4   r&   re   rq   rw   rU   ry   r|   r~   r   r   r   r   r   r5   r6   s   @r*   r\   r\   p   s    NG(T + + 9 9 D D D D H H/
Qfr+   r\   c                  D    e Zd ZU dZded<   d	dZd
dZd ZddZdddZ	y)rk   Nztuple[Any, Any, Index] | Nonefilterc                t    | j                   yt        d| j                   d    d| j                   d    d      S )NzFilter: Not Initializedz[Filter : [r   z] -> [r"   ])r   r   rN   s    r*   __repr__zFilterBinOp.__repr__-  s;    ;;,k$++a.)9A?OqQRRr+   c                    | j                   4| j                   d   | j                  d      | j                   d   f| _         | S )zinvert the filterr   T)invert   )r   generate_filter_oprN   s    r*   r   zFilterBinOp.invert2  sC    ;;"A''t'4ADK
 r+   c                    | j                   gS )zreturn the actual filter format)r   rN   s    r*   formatzFilterBinOp.format<  s    }r+   c                   | j                   st        d|  d      | j                  | j                        }t	        |      }| j
                  rV| j                  dv rGt        |      | j                  kD  r/| j                         }| j                  |t        |      f| _        | S y | j                  dv r/| j                         }| j                  |t        |      f| _        | S t        d|  d      )Nquery term is not valid [r   ==!=z7passing a filterable condition to a non-table indexer [)ry   
ValueErrorrw   rb   listr|   r^   lenr   r   ra   r   r   r   )r'   rb   values	filter_ops       r*   rm   zFilterBinOp.evaluateA  s    }}8a@AAll488$cww,&3v;9L9L+L 335	#xxE&MB 77l"//1I88Yf>DK 	 I$qQ r+   c                R    | j                   dk(  r|r| j                   dk(  r|rd S d S )Nr   r   c                &    | j                  |       S r;   isinaxisvalss     r*   <lambda>z0FilterBinOp.generate_filter_op.<locals>.<lambda>_  s    tyy&6 r+   c                $    | j                  |      S r;   r   r   s     r*   r   z0FilterBinOp.generate_filter_op.<locals>.<lambda>a  s    diio r+   )r^   )r'   r   s     r*   r   zFilterBinOp.generate_filter_op]  s'    GGtOF4F6655r+   r   r.   r
   r.   zSelf | None)F)r   r   )
r0   r1   r2   r   r4   r   r   r   rm   r   rd   r+   r*   rk   rk   *  s'    ,0F)0S

86r+   rk   c                      e Zd Zd ZddZy)rl   c                    t        d      )Nz unable to collapse Joint FiltersNotImplementedErrorrN   s    r*   r   zJointFilterBinOp.formate  s    !"DEEr+   c                    | S r;   rd   rN   s    r*   rm   zJointFilterBinOp.evaluatei  s    r+   Nr   )r0   r1   r2   r   rm   rd   r+   r*   rl   rl   d  s    Fr+   rl   c                  (    e Zd ZddZd Zd ZddZy)ri   c                4    t        d| j                   d      S )Nz[Condition : [z]])r   r_   rN   s    r*   r   zConditionBinOp.__repr__n  s    nT^^,<B?@@r+   c                    t        d      )zinvert the conditionz6cannot use an invert condition when passing to numexprr   rN   s    r*   r   zConditionBinOp.invertq  s    
 "D
 	
r+   c                    | j                   S )zreturn the actual ne format)r_   rN   s    r*   r   zConditionBinOp.formatz  s    ~~r+   c                   | j                   st        d|  d      | j                  sy | j                  | j                        }|D cg c]  }| j                  |       }}| j                  dv rSt        |      | j                  k  r:|D cg c]  }| j                  |       }}ddj                  |       d| _        | S y | j                  |d         | _        | S c c}w c c}w )Nr   r   r   r   z | r   r   )ry   r   r|   rw   rb   r   r^   r   r   r   joinr_   )r'   rb   r   r   vss        r*   rm   zConditionBinOp.evaluate  s    }}8a@AA ll488$145A$$$Q'55 77l"6{d1110671dmmA&77#$UZZ^$4A!6 	 !]]6!95DN 6 8s   CC#Nr   r   )r0   r1   r2   r   r   r   rm   rd   r+   r*   ri   ri   m  s    A

r+   ri   c                      e Zd ZddZy)rj   c                    d| j                   j                   d| j                   d| j                  j                   d| _        | S )Nr   r   r   )ra   r_   r^   rb   rN   s    r*   rm   zJointConditionBinOp.evaluate  s=    TXX//0$''!DHH<N<N;OqQr+   Nr   )r0   r1   r2   rm   rd   r+   r*   rj   rj     s    r+   rj   c                      e Zd Zd Zy)UnaryOpc                &   | j                   dk7  rt        d      | j                  }|j                  |      }|Xt	        |t
              r|j                  ,t	        |t
              s,t	        |t              r|j                  |j                         S y )N~z$UnaryOp only support invert type ops)
r^   r   operandrq   
issubclassri   r_   rk   r   r   )r'   rE   r   s      r*   rq   zUnaryOp.prune  s{    77c>%&LMM,,--&~.73D3D3Pun5uk2NN. >>##r+   N)r0   r1   r2   rq   rd   r+   r*   r   r     s    r+   r   c                  l     e Zd ZU eZded<   eZded<   d fdZddZ	d Z
d Zdd	Zd
 Zd Zd Z xZS )PyTablesExprVisitorzClassVar[type[ops.Term]]
const_typezClassVar[type[Term]]	term_typec                    t         |   |||       | j                  D ]&  }| j                  |   }t	        | d| |ffd	       ( y )Nvisit_c                &    t        t        |fi S r;   )r   r\   )nodebin_opkwargss     r*   r   z.PyTablesExprVisitor.__init__.<locals>.<lambda>  s    GE6,LV,L r+   )r%   r&   
binary_opsbinary_op_nodes_mapsetattr)r'   r9   engineparserr   r   bin_noder)   s       `  r*   r&   zPyTablesExprVisitor.__init__  sR    ff-oo 	F//7H
#$*L	r+   c                   t        |j                  t        j                  t        j                  f      r%t        d| j                  |j                              S t        |j                  t        j                        r@| j                  | j                  |j                        j                   | j                        S t        |j                  t        j                        rt        d      y )Nr   zUnary addition not supported)r<   r^   astNotInvertr   visitr   USubr   rR   r9   UAddr   r'   r   r   s      r*   visit_UnaryOpz!PyTablesExprVisitor.visit_UnaryOp  s    dgg453

4<< 899*??DJJt||$<$B$B#BDHHMM*%&DEEr+   c                L    | j                  |j                        j                  S r;   )r  rR   r  s      r*   visit_IndexzPyTablesExprVisitor.visit_Index  s    zz$**%+++r+   c                    t        j                  t        j                         g|j                  d   |j                  g      }| j                  |      S )Nr   )r   rJ   comparators)r  CompareEqtargetsrR   r  )r'   r   r   cmprs       r*   visit_Assignz PyTablesExprVisitor.visit_Assign  s>    {{
atzzl
 zz$r+   c                d   | j                  |j                        }| j                  |j                        }	 |j                  }t	        |t
              r|j                  }	 | j                  ||   | j                        S # t        $ r Y Gw xY w# t        $ r}t        d|d|      |d }~ww xY w)Nzcannot subscript z with )
r  rR   sliceAttributeErrorr<   r8   r   r9   r   r   )r'   r   r   rR   slobjerrs         r*   visit_Subscriptz#PyTablesExprVisitor.visit_Subscript  s     

4::&

4::&	KKE eT"KKE	T??5<::  		  	T0	yIJPSS	Ts)   B  !B  	BB	B/B**B/c                   |j                   }|j                  }t        |j                        }|t        j
                  k(  rE| j                  |      }	 |j                  }	 | j                  t        ||      | j                        S t        d|j                         # t        $ r Y Jw xY w# t        $ r0 t        |t        j                        r|j                  |k(  r|cY S Y _w xY w)NzInvalid Attribute context )attrrR   rX   ctxr  Loadr  r  r   r   r9   r<   Nameidr   r0   )r'   r   r   r  rR   r  resolveds          r*   visit_Attributez#PyTablesExprVisitor.visit_Attribute  s    yy

488n#((?zz%(H#>>$~~gh&=txxHH 5cll^DEE " 
 " $eSXX.588t3C#O$s$   B  %B- 	B*)B*-4C&%C&c                b    t        |t        j                        rt        j                         S |S r;   )r<   r  Inr  )r'   r^   s     r*   translate_Inz PyTablesExprVisitor.translate_In  s     %b#&&1svvx9r9r+   c                T    | j                  |j                        |j                  ||fS r;   )r  r^   )r'   r   rJ   rn   s       r*   _rewrite_membership_opz*PyTablesExprVisitor._rewrite_membership_op  s"    zz$''"DGGT588r+   r   )r.   zops.Term | UnaryOp | None)r.   zops.Term)r0   r1   r2   r>   r   r4   r8   r   r&   r  r  r  r  r#  r&  r(  r5   r6   s   @r*   r   r     sC    +3J(3&*I#*, T&F0:9r+   r   c                ^    t        | t        t        f      st        |       st	        d      | S )a  
    Validate that the where statement is of the right type.

    The type may either be String, Expr, or list-like of Exprs.

    Parameters
    ----------
    w : String term expression, Expr, or list-like of Exprs.

    Returns
    -------
    where : The original where clause if the check was successful.

    Raises
    ------
    TypeError : An invalid data type was passed in for w (e.g. dict).
    zLwhere must be passed as a string, PyTablesExpr, or list-like of PyTablesExpr)r<   PyTablesExprr=   r   r   )ws    r*   _validate_wherer,    s2    $ q<-.,q/+
 	

 Hr+   c                  X    e Zd ZU dZded<   ded<   ded<   	 	 	 d	 	 	 	 	 dd	Zdd
Zd Zy)r*  a  
    Hold a pytables-like expression, comprised of possibly multiple 'terms'.

    Parameters
    ----------
    where : string term expression, PyTablesExpr, or list-like of PyTablesExprs
    queryables : a "kinds" map (dict of column name -> kind), or None if column
        is non-indexable
    encoding : an encoding that will encode the query terms

    Returns
    -------
    a PyTablesExpr object

    Examples
    --------
    'index>=date'
    "columns=['A', 'D']"
    'columns=A'
    'columns==A'
    "~(columns=['A','B'])"
    'index>df.index[3] & string="bar"'
    '(index>df.index[3] & index<=df.index[6]) | string="bar"'
    "ts>=Timestamp('2012-02-01')"
    "major_axis>=20130101"
    zPyTablesExprVisitor | None_visitorr   r9   r=   r   Nc                (   t        |      }|| _        d | _        d | _        d | _        d | _        d }t        |t              r#|j                  j                  }|j                  }nt        |      rt        |      }t        |      D ]:  \  }}t        |t              r|j                  j                  }-t        |      ||<   < dj                  t        j                   |      D cg c]  }d| d
 c}      }n|}|| _
        t#        |dz   |      | _        |ut        | j                  t$              rZ| j                  j&                  j)                  |       t+        | j                  |dd|      | _        | j-                         | _        y y y c c}w )Nz & r   r   r"   )r$   pytables)r   r  r  rD   )r,  rD   r_   r   termsr.  r<   r*  r9   r   r   r   r   	enumerater   comflattenr   r=   r   updater   parse)	r'   wherer   rD   scope_levelr$   _whereidxr+  s	            r*   r&   zPyTablesExpr.__init__C  s[     & 
 <@
e\*JZZF% KE#E* 4Qa.!"J!0!3E#J	4
 ZZ3;;u3E Fa1QCq FGF F	 qZH!jC&@HH&&z2/%!!!DM DJ 'A! !Gs   $Fc                n    | j                   t        | j                         S t        | j                        S r;   )r1  r   r   rN   s    r*   r   zPyTablesExpr.__repr__s  s*    ::!

++DII&&r+   c                ~   	 | j                   j                  t              | _        	 | j                   j                  t              | _        | j                  | j                  fS # t        $ r"}t        d| j                   d|  d      |d}~ww xY w# t        $ r"}t        d| j                   d|  d      |d}~ww xY w)z2create and return the numexpr condition and filterzcannot process expression [z], [z] is not a valid conditionNz] is not a valid filter)	r1  rq   ri   r_   r  r   r   rk   r   )r'   r  s     r*   rm   zPyTablesExpr.evaluatex  s    	!ZZ--n=DN	****;7DK ~~t{{**  	-dii[TF C+ + 	  	-dii[TF C( ( 	s.   $A# $B #	B,B		B	B<B77B<)NNr   )r   r-   r8  r,   r.   r/   r   )r0   r1   r2   __doc__r4   r&   r   rm   rd   r+   r*   r*  r*  #  sS    6 )(	
I
 -1.& *.&
 .& 
.&`'
+r+   r*  c                       e Zd ZdZddZddZy)r   z<hold a term value the we use to construct a condition/filterc                \    t        |t              sJ |       || _        || _        || _        y r;   )r<   r=   rR   	convertedr~   )r'   rR   r@  r~   s       r*   r&   zTermValue.__init__  s,    $$*d*$
"	r+   c                    | j                   dk(  r'|t        | j                        S d| j                   dS | j                   dk(  rt        | j                        S t        | j                        S )z6quote the string if not encoded else encode and returnr   "r   )r~   r=   r@  repr)r'   rD   s     r*   r   zTermValue.tostring  sc    99 #4>>**t~~&a((YY'! ''4>>""r+   N)r~   r=   r.   r/   r   )r0   r1   r2   r=  r&   r   rd   r+   r*   r   r     s    F
#r+   r   c                     t         t              syt        j                  t        j                  z   dz   }t         fd|D              S )z7loose checking if s is a pytables-acceptable expressionF)=c              3  &   K   | ]  }|v  
 y wr;   rd   ).0r^   r   s     r*   	<genexpr>z#maybe_expression.<locals>.<genexpr>  s     ,2rQw,s   )r<   r=   r   r   	unary_opsany)r   
operationss   ` r*   maybe_expressionrL    s@    a$//2E2O2OORXXJ ,,,,r+   r   )Cr=  
__future__r   r  decimalr   r   	functoolsr   typingr   r   r	   r
   r   numpyrt   pandas._libsr   pandas._libs.tslibsr   r   pandas.errorsr   pandas.core.dtypes.commonr   pandas.core.commoncorecommonr3  pandas.core.computationr   r   r   _scopepandas.core.computation.commonr   pandas.core.computation.exprr   pandas.core.computation.opsr   pandas.core.constructionr   pandas.core.indexes.baser   pandas.io.formats.printingr   r   pandas._typingr   r   Scoper   r8   r>   r\   rk   rl   ri   rj   r   r   r,  Exprr*  r   rL  rd   r+   r*   <module>rd     s   5 " 
     1 2     
 : 8 / 2 *
 +FLL + 388 Bt wCII wt76% 76t{ *U *Z. ckk (P9/ P9f6f+499 f+R# #,-r+   