
    AHj                       U d Z ddlmZ ddlZddlZddlZddlZddlZddl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 dd	lmZ dd
lmZmZmZmZmZ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dl!m%Z& ddlm'Z' ddlm(Z( ddlm)Z)  G d de      Z*ed   Z+de,d<   e-e*z  Z.de,d<   ej^                  dk\  Z0de,d<   e0xr ej^                  dk\  Z1de,d<   e1xr ej^                  dk\  Z2de,d<    ed      Z3d e,d!<    G d" d#      Z4 e5d$      Z6d%e,d&<    e5d'      Z7d%e,d(<    e5d)      Z8d%e,d*<   d+d,d-d.d/d0d1d2d3Z9d4e,d5<   d6d7d8d9Z:d4e,d:<    e5e:      d;hz  Z;d%e,d<<   i d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcddZ<d4e,de<    G df dgedhi      Z=djdkhgg e4j|                  gg e7gg e8gdldjdkhgg e4j|                  gg dmhgg e6gdldjhgg e4j|                  gg dnhgg dohgdldjhgdkhge4j|                  gg dphgg dqhgdhdrdjhgdkhgdshge4j|                  gdpdthgdphgdqhgdhdrgZ?due,dv<    e@e4j                        gg gZBdwe,dx<   e?D  cg c]  } eBD ]
  }i | dy|i  c}} Z?dzd{d|d}d~dddZCd4e,d<    ej                  d      ZEde,d<    ej                  d      ZFde,d<    ej                  d      ZGde,d<   ddZHddZI G d d      ZJ G d d      ZK G d d      ZLddZM	 	 	 	 	 	 	 	 ddZNddgZOyc c}} w )zNUtilities related to user defined functions (such as those passed to `apply`).    )annotationsN)bisect_left)defaultdict)get_instructions)	signature)countzip_longest)Path)TYPE_CHECKINGAnyClassVarFinalLiteral
NamedTuple	TypedDict)LRUCache)
NO_DEFAULT	re_escape)CallableIteratorMutableMapping)Set)Instruction)	TypeAlias)	NoDefaultc                  D    e Zd ZU ded<   ded<   ded<   ded<   dZded	<   y)

StackValuestroperatorintoperator_arityleft_operandright_operandN
str | Nonefrom_module)__name__
__module____qualname____annotations__r%        J/root/tools/cai/cai_env/lib/python3.12/site-packages/polars/_utils/udfs.pyr   r   '   s#    M"K"r+   r   )exprframeseriesr   	MapTarget
StackEntry)      r   
_MIN_PY311)r2      
_MIN_PY312)r2      
_MIN_PY314    z@MutableMapping[tuple[Callable[[Any], Any], str], BytecodeParser]_BYTECODE_PARSER_CACHE_c                     e Zd ZU ddddddddd	d
dddZded<    eerdhnddh      Zer	esdddddndddddZ	ded<    ed      Z
 eddh      Ze
ez  ZdddZded<   ddiZded <   d
dd!d"Zded#<    eh d$ ee      z   ee	      z   ee      z  e
z        Z ee      ez   ee      z  ez  ez  Z eej'                               Zy%)&OpNames+&z//<<>>%*|z**-/^)
BINARY_ADD
BINARY_ANDBINARY_FLOOR_DIVIDEBINARY_LSHIFTBINARY_RSHIFTBINARY_MODULOBINARY_MULTIPLY	BINARY_ORBINARY_POWERBINARY_SUBTRACTBINARY_TRUE_DIVIDE
BINARY_XORzClassVar[dict[str, str]]BINARYCALLCALL_FUNCTIONCALL_METHOD)POP_JUMP_FORWARD_IF_FALSEPOP_JUMP_FORWARD_IF_TRUEJUMP_IF_FALSE_OR_POPJUMP_IF_TRUE_OR_POP)POP_JUMP_IF_FALSEPOP_JUMP_IF_TRUErY   rZ   CONTROL_FLOW)
LOAD_CONST
LOAD_DEREF	LOAD_FASTLOAD_GLOBALLOAD_METHOD	LOAD_ATTRr`   r^   )LOAD_FAST_BORROWLOAD_SMALL_INTSIMPLIFY_SPECIALIZEDPOLARS_EXPRESSION   zClassVar[dict[str, int]]	SYNTHETIC~)UNARY_NEGATIVEUNARY_POSITIVE	UNARY_NOTUNARY>   IS_OP	BINARY_OP
COMPARE_OPCONTAINS_OPBINARY_SUBSCRN)r&   r'   r(   rS   r)   	frozensetr4   rT   r6   r]   LOAD_VALUESrc   LOADrf   ri   rn   setPARSEABLE_OPSMATCHABLE_OPSvaluesUNARY_VALUESr*   r+   r,   r<   r<   ;   sl   #!(F$  fX/=1QRD j *-(+$'#&		
 "% #$'#&	
 *   TUK=+67I"D'&62 
 	Q+I'  'E# 
 L
e*	
l
	 i.	 		M 	 !M1CK?)KdR  U\\^,Lr+   r<   )acosacoshasinasinhatanatanhcbrtceilcoscoshdegreesexpfloorloglog10log1ppowradianssinsinhsqrttantanhzFinal[frozenset[str]]_MATH_FUNCTIONS)npnumpy_NUMPY_MODULE_ALIASES)arccosarccosharcsinarcsinharctanarctanhr   r   r   r   r   r   r   r   r   r   r   signr   r   r   r   r   _NUMPY_FUNCTIONSz	dt.date()zdt.day()z	dt.hour()zdt.microsecond()zdt.minute()z
dt.month()zdt.second()z	dt.year())datedayhourmicrosecondminutemonthsecondyearzFinal[dict[str, str]]_PYTHON_ATTRS_MAPFloat64Int64String)floatr    r   _PYTHON_CASTS_MAPabs_PYTHON_BUILTINSendswithstr.ends_withlowerzstr.to_lowercaselstripzstr.strip_chars_startremoveprefixzstr.strip_prefixremovesuffixzstr.strip_suffixreplacestr.replacerstripzstr.strip_chars_end
startswithstr.starts_withstripzstr.strip_charstitlezstr.to_titlecaseupperzstr.to_uppercasezfillz	str.zfillr   zdt.dater   zdt.dayr   zdt.hour
isoweekdayz
dt.weekdayr   zdt.microsecondzdt.monthz	dt.secondzdt.strftimezdt.timezdt.year)r   r   strftimetimer   _PYTHON_METHODS_MAPc                  r    e Zd ZU ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded	<   ded
<   ded<   y)ModuleFunctionlist[AbstractSet[str]]argument_1_opnameargument_2_opnameargument_1_unary_opnameargument_2_unary_opnamemodule_opnameattribute_opnamemodule_nameattribute_namefunction_nameboolcheck_load_globalN)r&   r'   r(   r)   r*   r+   r,   r   r      s>    ----3333)),,''**))r+   r   F)totalr`   r^   )r   r   r   r   r   r   r   mathjsonloadsdatetimestrptime)r   r   r   r   r   r   r   r   rc   dtzlist[ModuleFunction]_MODULE_FUNCTIONSzlist[list[AbstractSet[str]]]_UNARIESr   r   r   r   r   r   r   str.json_decode)z	math.acosz
math.acoshz	math.asinz
math.asinhz	math.atanz
math.atanhz
json.loads_MODULE_FUNC_TO_EXPR_NAMEz,pl\.col\("([^"]*)"\) & pl\.col\("\1"\)\.(.+)_RE_IMPLICIT_BOOLz^(s|srs\d?|series)\._RE_SERIES_NAMESz^bool\((.+)\)$_RE_STRIP_BOOLc                 Z   t        t              j                  j                  } t        j                         }d}	 |rEt        j
                  |      }|j                  t        |             r|j                  }|dz  }nn|rE|i }~|S i |j                  |j                  }	 ~|S # ~w xY w)z7Get all local and global variables from caller's frame.r   rh   )r
   __file__parentinspectcurrentframegetfiler   r   f_backf_locals	f_globals)pkg_dirr.   nfname	variabless        r,   _get_all_caller_variablesr   <  s    8n##**G   "E	AOOE*EG-Q  =I  >5>>=U__=I  s   AB' B' 	B' 'B*c                t   d|  d}|dk(  r|S |dk(  rt         j                  |      r|j                  dd      d   S |j                  |d      }d	D ]   }t	        j
                  d
| d
|      r|c S  t               }	 dt        |       }t	        j
                  d
| d
|      s|S +d|}t        |      )z@The name of the object against which the 'map' is being invoked.pl.col("")r-   r/   .rh   r    )ssrsr/   z\br   zTODO: map_target = )	r   matchsplitr   researchr   nextNotImplementedError)col
expression
map_targetcol_exprsearch_exprnamer   msgs           r,   _get_target_namer   Y  s    #b!HV	x	!!*-##C+A.. !((26* 	D994&^[9	 Ga	?D994&^[9 
  
~
.C
c
""r+   c                     e Zd ZU dZdZded<   dZded<   dZded<   eZ	d	ed
<   ddZ
ddZedd       Z	 	 	 	 	 	 ddZedd       ZddZddZed d       Zed!d       Zed"d       Zed!d       Zd#dZddd	 	 	 	 	 	 	 d$dZy)%BytecodeParserzMIntrospect UDF bytecode and determine if we can rewrite as native expression.Nr$   _map_target_namezbool | None_can_attempt_rewritedict[str, Any] | None_caller_variablesz"tuple[str, str] | NoDefault | None_col_expressionc                    	 t        |      }|| _        || _        | j                  |      | _        t        || j                  |      | _	        y# t        $ r t        g       }Y Xw xY w)aI  
        Initialize BytecodeParser instance and prepare to introspect UDFs.

        Parameters
        ----------
        function : callable
            The function/lambda to disassemble and introspect.
        map_target : {'expr','series','frame'}
            The underlying target object type of the map operation.
        )instructionscaller_variablesfunctionN)
r   	TypeErroriter	_function_map_target_get_param_name_param_nameRewrittenInstructionsr  _rewritten_instructions)selfr  r   original_instructionss       r,   __init__zBytecodeParser.__init__z  so    	-$4X$>! "%//9'<.!33(
$  	- %)H!	-s   A A&%A&c                    t         j                  |      r-t         j                  d|      }t         j                  |      r-|S )zIDrop extraneous/implied bool (eg: `pl.col("d") & pl.col("d").dt.date()`).zpl.col("\1").\2)replstring)r   r   sub)r  r-   s     r,   _omit_implicit_boolz"BytecodeParser._omit_implicit_bool  s;    &&t,$((.@(ND  &&t,r+   c                    	 t        |       }t        |j                  x}      dk(  r"t	        t        |j                                     S dS # t        $ r Y yw xY w)z&Return single function parameter name.Nrh   )r   
ValueErrorlen
parametersr   r  keys)r  sigr  s      r,   r  zBytecodeParser._get_param_name  sb    	H%C
 /:0A5 joo'()	
 	
  		s   A 	AAc                   |rt        |D ch c]  }|j                   c}      dkD  rt        |j                               }d}|D ]i  }|t	        ||j
                        dz
     }|t	        ||j                        dz
     }|dk(  r	||d   k(  rI|||fvsPd||   z   ||<   ||xx   dz  cc<   |}k |D ],  }t        j                  |j                     ||j
                  <   . t        |j                               S c c}w )zBInject nesting boundaries into expression blocks (as parentheses).rh   r   ())r  opnamelistr   r   offsetargvalr<   r]   sorteditems)r  expression_blockslogical_instructionsinstblock_offsetsprev_endstartends           r,   _inject_nestingzBytecodeParser._inject_nesting  s      ,@ADDKKABQF+/0A0F0F0H+I0 +D)+mT[[*QTU*UVE'M4;;(ORS(STC!QJ3-2C+C#E3<77:=Nu=U7U-e4-c2c92'*H+ - S181E1Edkk1R!$++.S '--/00 Bs   C<c                    | j                   S )z8The map target, eg: one of 'expr', 'frame', or 'series'.)r  r  s    r,   r   zBytecodeParser.map_target       r+   c                
   | j                   l| j                  duxrW t        | j                        dk\  xr= t	        d | j                  D              xr t        d | j                  D              dk(  | _         | j                   S )aN  
        Determine if we may be able to offer a native polars expression instead.

        Note that `lambda x: x` is inefficient, but we ignore it because it is not
        guaranteed that using the equivalent bare constant value will return the
        same output. (Hopefully nobody is writing lambdas like that anyway...)
        N   c              3  T   K   | ]   }|j                   t        j                  v  " y wN)r&  r<   rx   .0r.  s     r,   	<genexpr>z5BytecodeParser.can_attempt_rewrite.<locals>.<genexpr>  s'       KK7#8#88s   &(c              3  >   K   | ]  }|j                   d k(  rd  yw)RETURN_VALUErh   N)r&  r;  s     r,   r=  z5BytecodeParser.can_attempt_rewrite.<locals>.<genexpr>  s$      {{n4 s   rh   )r  r  r  r  allsumr  r5  s    r,   can_attempt_rewritez"BytecodeParser.can_attempt_rewrite  s     $$,  , 445:   $ < <    $ : : 
  %  (((r+   c                B    t        j                   | j                         y)z%Print disassembled function bytecode.N)disr  r5  s    r,   rD  zBytecodeParser.dis  s    r+   c                    | j                   S )zThe function being parsed.)r  r5  s    r,   r  zBytecodeParser.function  s     ~~r+   c                @    t        | j                  j                        S )zDThe original bytecode instructions from the function we are parsing.)r'  r  _original_instructionsr5  s    r,   r  z$BytecodeParser.original_instructions  s     D00GGHHr+   c                    | j                   S )z0The parameter name of the function being parsed.)r  r5  s    r,   
param_namezBytecodeParser.param_name  r6  r+   c                ,    t        | j                        S )zEThe rewritten bytecode instructions from the function we are parsing.)r'  r  r5  s    r,   rewritten_instructionsz%BytecodeParser.rewritten_instructions  s     D0011r+   c                   | j                   t        ur\| j                   P| j                   \  }}||k7  r:t        j                  dt	        |       ddt	        |       d|      }||f| _         |S d| _        | j                  d| _         yt        t              }g }d}t        | j                        D ]c  \  }}|j                  t        j                  v r.| j                  |dz      j                  }|j                  |       P||   j                  |       e 	 | j!                  |j#                         D 	
ci c]a  \  }	}
|	t%        |
| j&                  | j(                  | j*                        j-                  || j                  t/        t1        |            	      c c}
}	|      }d
j5                  d |D              }d|vrd| _         y| j7                  |      }| j(                  dk(  r;| j
                  x}t9        ||| j(                        }|j;                  d| d|      }||f| _         |S c c}
}	w # t2        $ r
 d| _         Y yw xY w)zDTranslate postfix bytecode instructions to polars expression/string.Nz
pl\.col\("z"\)r   r   r   rh   )r	  r
  r   r  )r   rI  depth c              3  &   K   | ]	  \  }}|  y wr:  r*   )r<  _offsetr-   s      r,   r=  z/BytecodeParser.to_expression.<locals>.<genexpr>.  s     LtLs   pl.col(r/   )r  r   r   r  r   r  r  r   r'  	enumerater  r&  r<   r]   r(  appendr3  r+  InstructionTranslatorr  r  r  to_expressionr    r   r   joinr  r   r   )r  r   col_namer-   control_flow_blocksr-  jump_offsetidxr.  r(  opsexpression_stringspolars_exprtarget_names                 r,   rU  zBytecodeParser.to_expression  so   z1d6J6J6V!11NHdhvv!)H"5!6c:y~.b1
 ),T{$K $##'D  *$/!"4#?#?@ 	>IC{{g222"::37CJJ$++D1#K077=	>	!%!5!5 (;'@'@'B $ 1%()-)?)?#'#3#3!%	
 $m#'#3#3!$';"<= $ 	 %"( hhL9KLL K'#'D 22;?K8+#'#8#88KA"23TEUEU"VK)11HSE2DkR$'#5D E # 	#'D 	s%   H6 7A&H0
	H6 0H6 6I	I	suggestion_overrideudf_overridec          
        ddl m} ddlm} ddlm} |xs | j                  |      }|| j                  x}t        ||| j                        }|xs | j                  j                  xs d}	|	dk(  rd| j                   d	}	d
|v rdnd}
| j                  dk(  rdnd\  }} |       rd| d|	 dd| d|
 fnd| d|	 dd| d|
 f\  }}t        j                  d| d| d| d| | |              yy)zFGenerate warning that suggests an equivalent native polars expression.r   ) in_terminal_that_supports_colour)find_stacklevel)PolarsInefficientMapWarningNz...z<lambda>zlambda z: ...z
pl.col("")zHNote: in list.eval context, pl.col("") should be written as pl.element()r   r-   )expressionsExpr)r/   Seriesz	  [31m- z.map_elements(z)[0m
z	  [32m+ z[0m
z  - z)
z  + 
z6.map_elements is significantly slower than the native zc API.
Only use if you absolutely CANNOT implement your logic otherwise.
Replace this expression...
zwith this one instead:
)
stacklevel)polars._utils.variousrc  polars._warningsrd  polars.exceptionsre  rU  r  r   r  r  r&   r  warningswarn)r  r   r`  ra  rc  rd  re  suggested_expressionr^  	func_nameaddendumapitypeclsnamebeforeafters                  r,   ro  zBytecodeParser.warn?  su   	
 	5A2Md6H6H6M+#444=.-t/?/? %H(?(?H5IJ&%d&6&6%7u=	  #77 [  ##v- () GW 45 #;-~i[
S"#7"8	(L ;-~i[D/08*= FE MMWIST[S\ ]/ (*' ,*,	= ,r+   )r  Callable[[Any], Any]r   r0   returnNone)r-   r   rx  r   )r  rw  rx  r$   )r,  zdict[int, str]r-  list[Instruction]rx  zlist[tuple[int, str]])rx  r0   )rx  r   )rx  ry  )rx  rw  )rx  rz  )rx  r$   )r   r   rx  r$   )r   r   r`  r$   ra  r$   rx  ry  )r&   r'   r(   __doc__r  r)   r  r  r   r  r  r  staticmethodr  r3  propertyr   rB  rD  r  r  rI  rK  rU  ro  r*   r+   r,   r  r  r  s   W#'j'(,+,/3,3:DO7D
6 
 
1)1 01 
	14    )6    I I     2 2BP +/#'99 (	9
 !9 
9r+   r  c                  b    e Zd ZdZ	 	 	 	 	 	 	 	 	 	 ddZd	dZed
d       ZddZ	 	 	 	 	 	 ddZ	y)rT  z>Translates Instruction bytecode to a polars expression string.c                N    | j                  ||      | _        || _        || _        y r:  )_to_intermediate_stack_stackr  r  )r  r	  r
  r  r   s        r,   r  zInstructionTranslator.__init__~  s'     11,
K!1!r+   c                >    | j                  | j                  |||      S )z7Convert intermediate stack to polars expression string.)_exprr  )r  r   rI  rM  s       r,   rU  z#InstructionTranslator.to_expression  s    zz$++sJ>>r+   c                d   | j                   x}t        j                  v rt        j                  |   S | j                  r| j                  S |dk(  r| j                  rdS dS |dk(  r| j                  rdS dS |t        j
                  v rt        j
                  |   S |dk(  ryd	| d
| }t        |      )z@Convert bytecode instruction to suitable intermediate op string.ro   is notisrr   not ininrs   replace_strictz$unexpected or unrecognised op name (z)

Please report a bug to https://github.com/pola-rs/polars/issues with the content of function you were passing to the `map` expression and the following instruction object:
)r&  r<   r]   argreprr)  rn   AssertionError)r.  r&  r   s      r,   opzInstructionTranslator.op  s     kk!Fg&:&::''//\\<<w#{{844}$#{{844w}}$==((&# 7vh ?E FJHN  !%%r+   c                   t        |t              r6t        j                  d|j                        }| j                  |j                  |||dz         }|j                  dk(  r|t        j                  vr|j                  d      r|j                  d      rdnd}| d| | S |d   t        j                  v r3|dd	 j                  d      r|j                  d      rdnd}d
| d| | S |j                  t        v r|t        v rd}n3|j                  dk(  r"t        j!                  d| |      t"        v rd}nd}| | d
| dS | | S | j                  |j$                  |||dz         }	|dv r |j                  dk(  r|dk(  rdnd}
| d|
 dS |dv r"|dk(  rdnd}
d|v r|
 d
| d|	 dS |
 | d|	 dS |dk(  r]| j&                  st)               | _        t        | j&                  j!                  |d	      t*              sd}t-        |      |	 d| d
| dS |dk(  r	d
| d|	 dS |d k(  r	d
| d!|	 dS | d| d|	 }|rd
| dS |S ||k(  rd"| d#S |S )$z?Take stack entry value and convert to polars expression string.z\1rh   rQ  r%  r   ()r   r   Nr$  z).znp.r   math.)r  r  ry  r  not_z.is_znull())r  r  r  rj   rN  z.is_in(z))r  zrequire dict mappingr?   z * 2**z).cast(pl.Int64)r@   z / 2**r   r   )
isinstancer   r   r  r   r  r"   r!   r<   r{   r   r   r%   r   r   r   getr   r#   r  r   dictr   )r  valuer   rI  rM  r  e1callpfxe2r  r   r-   s                r,   r  zInstructionTranslator._expr  s   eZ(##E5>>:BE..ZKB##q(W111}}Y/%'[[%5r4"$Qrd4&11!u 4 44AB9J9J99U%'[[%5r4!"2$bTF33
 ))-BB"22#))V3599E",K*+ & !U2$at1--bT{"ZZ 3 3S*eaiP))e.@.@F.J!#t2D TdV622++!#t2D "9  &"WRD3 !%vbTA6
 ++111J1L.%d&<&<&@&@T&JDQ41#66 T2$at1--4Z rd&,<==4Zrd&,<== T2$at,D*/QtfA;9T9j cU"%%r+   c                L   |dv rg }|D ]  }|j                  |j                  t        j                  v r|j                  n|j                  t        j
                  v s,t        j                  j                  |j                        dk(  r8t        | j                  |      d|j                         dt        |dd            nGt        | j                  |      d|j                  d      |j                  d      t        |dd                    |d	   S d
|d}t        |      )zITake postfix bytecode and convert to an intermediate natural-order stack.)r-   r/   rh   N_from_module)r   r!   r"   r#   r%   r8  r#  r   zTODO: z map target not yet supported.)rS  r&  r<   rv   r  rn   ri   r  r   r  popgetattrr   )r  r	  r   stackr.  r   s         r,   r  z,InstructionTranslator._to_intermediate_stack  s    ++&(E$ {{gll2 LL !KK7==8&0044T[[AQF #%)WWT]+,).*.(/nd(K (%)WWT]+,).2*/))B-(/nd(K2 8O zn$BC!#&&r+   N)
r	  rz  r
  r  r  rw  r   r0   rx  ry  )r   r   rI  r   rM  r    rx  r   )r.  r   rx  r   )
r  r1   r   r   rI  r   rM  r    rx  r   )r	  rz  r   r0   rx  r1   )
r&   r'   r(   r{  r  rU  r|  r  r  r  r*   r+   r,   rT  rT  {  sw    H	"'	" 0	" '		"
 	" 
	"? & &.AF#'-#';D#'	#'r+   rT  c                     e Zd ZdZ eg d      Z	 	 	 	 	 	 	 	 ddZddZddZddZ	dd	 	 	 	 	 	 	 	 	 dd	Z
dd
ZddZ	 	 	 	 	 	 ddZ	 	 	 	 	 	 ddZ	 	 	 	 	 	 ddZe	 	 	 	 dd       Zedd       Z	 	 	 	 	 	 	 	 ddZy)r  a]  
    Standalone class that applies Instruction rewrite/filtering rules.

    This significantly simplifies subsequent parsing by injecting
    synthetic POLARS_EXPRESSION ops into the Instruction stream for
    easy identification/translation, and separates the parsing logic
    from the identification of expression translation opportunities.
    )	COPYCOPY_FREE_VARS	NOT_TAKENPOP_TOPPRECALL	PUSH_NULLRESUMEr?  TO_BOOLc                p   || _         || _        t        |      | _        g }| j	                  | j                        D ]b  }|j
                  | j                  vs|j
                  t        j                  vr	g | _	         y | j                  |      }|j                  |       d | j                  |      | _	        y r:  )r  r  r'  rG  _unpack_superinstructionsr&  _ignored_opsr<   ry   r  _update_instructionrS  _rewrite)r  r	  r  r
  normalised_instructionsr.  upgraded_insts          r,   r  zRewrittenInstructions.__init__&  s     "!1&*<&8#"$2243N3NO 	>D{{$"3"33;;g&;&;;35D0 $ 8 8 >'..}=	> (,}}5L'M$r+   c                ,    t        | j                        S r:  )r  r  r5  s    r,   __len__zRewrittenInstructions.__len__<  s    4//00r+   c                ,    t        | j                        S r:  )r  r  r5  s    r,   __iter__zRewrittenInstructions.__iter__?  s    D0011r+   c                     | j                   |   S r:  )r  )r  items     r,   __getitem__z!RewrittenInstructions.__getitem__B  s    ++D11r+   F)is_attrc                  t        |      |xs g }}||z   }|r5| j                  ||dz    x}r!|d   j                  t        j                  v rg S | j                  || }t        |      |k(  rt        d t        |||      D              r|S g S )a  
        Check if a sequence of Instructions matches the specified ops/argvals.

        Parameters
        ----------
        idx
            The index of the first instruction to check.
        opnames
            The full opname sequence that defines a match.
        argvals
            Associated argvals that must also match (in same position as opnames).
        is_attr
            Indicate if the match represents pure attribute access (cannot be called).
        rh   r   c              3  l   K   | ],  \  }}}|j                   |v xr |d u xs |j                  |v  . y wr:  )r&  r)  )r<  r.  match_opnamesmatch_argvals       r,   r=  z1RewrittenInstructions._matches.<locals>.<genexpr>e  sK      7
 2m\ KK=( F%D)DF7
s   24)r  _instructionsr&  r<   rT   r@  r	   )	r  rZ  opnamesargvalsr  n_required_ops
idx_offsettrailing_instr	  s	            r,   _matcheszRewrittenInstructions._matchesE  s    , #&g,2>)
"&"4"4Z*q."QQQa ''7<<7I))#j9|.3 7
 6Agw67
 4
  	r+   c                   || _         g dt        | j                         k  r| j                      dc}|j                  t        j                  vsBt        fd| j                  | j                  | j                  | j                  fD              sj                  |       xs dz  t        | j                         k  rS )a#  
        Apply rewrite rules, potentially injecting synthetic operations.

        Rules operate on the instruction stream and can examine/modify
        it as needed, pushing updates into "updated_instructions" and
        returning True/False to indicate if any changes were made.
        r   rh   c              3  4   K   | ]  } |      x  y wr:  r*   )r<  map_rewriterZ  	incrementupdated_instructionss     r,   r=  z1RewrittenInstructions._rewrite.<locals>.<genexpr>|  s)      	: *#/CDDD	:s   )r  r  r&  r<   rv   any_rewrite_functions_rewrite_methods_rewrite_builtins_rewrite_attrsrS  )r  r	  r.  rZ  r  r  s      @@@r,   r  zRewrittenInstructions._rewriteo  s     *24C**++"005qOD){{',,.c 	: ++))**''$	: 	7 %++D19>!C C**++ $#r+   c                    | j                  |dhdhgdt        gd      x}rB|d   }t        |j                     }|j                  d||      }|j	                  |d	   |g       t        |      S )
zDReplace python attribute lookup with synthetic POLARS_EXPRESSION op.r`   rc   NT)r  r  r  rh   rg   r&  r)  r  r   )r  r   r)  _replaceextendr  )r  rZ  r  matching_instructionsr.  	expr_namepxs          r,   r  z$RewrittenInstructions._rewrite_attrs  s    $(MM!][M2,-	 %2 %
 
  
 )+D)$++6I*9i  B !'')>q)A2(FG())r+   c                h   | j                  |dhddht        j                  gt        g      x}ry|dd \  }}|j                  x}t
        v rt
        |   }d| d}|j                  d	|||j                  
      }|j                  |j                        }	|j                  |	|f       t        |      S )zEReplace builtin function calls with a synthetic POLARS_EXPRESSION op.ra   r`   r^   r  r  Nr8  cast(pl.r%  rg   r&  r)  r  r(  r(  )
r  r<   rT   r   r)  r   r  r(  r  r  )
r  rZ  r  r  inst1inst2r)  dtyper  operands
             r,   r  z'RewrittenInstructions._rewrite_builtins  s     %)MM#_{L&A7<<P%& %2 %
 
  

 1!4LE5,,&+<<)&1#E7!,*||	   B nnELLn9G ''"6())r+   c           	     4   dD ]  }t         D ]  }|r|j                  dd      s  y|r$ddhg|d   |d   |d	   t        j                  n-ddhg|d
   |d   |d   |d   |d	   t        j                  }|d   }| j	                  |||rg |d   ng |d   |d   |d         x}st        |d         }||d|z    \  }	}
}|r| j                  st               | _        |	j                  x}| j                  vr| j                  |   j                  t        fd|D              s$t        j                   d| |      }n|	j                  dk(  rd}n|	j                  dk(  rQ||dz      j                  }d| d}| j                  |	j                  |d   j                  |      sXt        |      c c S |	j                  dk(  r.t        j                  d|
j                   |
j                        }n|
j                  }|r|
n|}|	j                  d|||j                        }|rdn|	j                  xs d|_        |j                  |	j                        }|j!                  |d   r||d|z      |fn||f       t        |      c c S   y)z=Replace function calls with a synthetic POLARS_EXPRESSION op.)FTr   Tr   ra   r_   r   r   r   r   r   r   r   r   r  r2   c              3  &   K   | ]  }|v  
 y wr:  r*   )r<  mr   s     r,   r=  z;RewrittenInstructions._rewrite_functions.<locals>.<genexpr>  s     &Raq(8&Rs   r   r   r   r   zstr.to_datetime(format="r   r   r  rg   r  Nr  )r   r  r<   rT   r  r  r  r   r)  r'   r  r   _is_stdlib_datetimer  r(  r  r  )r  rZ  r  check_globalsfunction_kindr  module_aliasesr  attribute_countr  r  inst3r  fmt	swap_instr  r  r   s                    @r,   r  z(RewrittenInstructions._rewrite_functions  sz    + ]	6M!2 \6 ):):;NPT)U % '5&':; ''@A '':;	
   '5&7 ''9: '':;	
 ''@A '':;   & "/}!=,0MM# %&7&}5&'78 '7 -: - (  '*-8H*I&JO*?'!o*=+'E5% %#555N5PD2).5Id>T>TT$*.*@*@*K*V*VK#&&R>&R#R ((A(E(E#.-q <i)I /$5	33Oa4GHOO&>se2$F	#77!LL1!4;;+  $''<#==/$=$A$A#ELL>2ELL%	 %*LL	 *7EI2( )(//	 ( B /<d%,,BVRVBO'000EG(// ))BC	 $1!o2EF &r] 455y\6]	6~ r+   c           	        t         rt        j                  ndh}| j                  ||dht        j                  gt
        g      xs) | j                  ||t        j                  gt
        g      x}r|d   }t
        |j                     }|d   j                  dk(  rh|d   j                  }t        |t              r@|dv r<d|v rdnd	\  }}	d
j                  d |D              }
d|v rdnd}d| | d|
 d|	 | d	}n	|d|dz  }|j                  d||      }|j                  |       t        |      S | j                  ||dhdhdht        j                  gt
        g      xs- | j                  ||dhdht        j                  gt
        g      x}r|d   }t
        |j                     }|dt        |      dz
   D cg c]  }|j                   }}|dk(  r3t        |      dk(  r|\  }}}|d|d|d| dz  }n.|\  }}d|d|d}n|ddj                  d |D               dz  }|j                  d||      }|j                  |       t        |      S c c}w )z@Replace python method calls with synthetic POLARS_EXPRESSION op.rb   r^   r  r   rh   )r   r   starts)rF   r   )r   $rC   c              3  2   K   | ]  }t        |        y wr:  )r   r<  vs     r,   r=  z9RewrittenInstructions._rewrite_methods.<locals>.<genexpr>8  s     !D1)A,!D   '"zstr.contains(rr$  r%  rg   r  r   r2   ,z,n=z,literal=True)zstr.replace_all(c              3  2   K   | ]  }t        |        y wr:  )reprr  s     r,   r=  z9RewrittenInstructions._rewrite_methods.<locals>.<genexpr>e  s     $CT!W$Cr  )r6   r<   rc   r  rT   r   r)  r&  r  tuplerV  r  rS  r  )r  rZ  r  rb   r  r.  r-   param_valuer  endsrxqr  iparam_valuesoldnewr   s                     r,   r  z&RewrittenInstructions._rewrite_methods  s    ,6g''M? MM$|ngllC,-    MM$gll3,-  
  
 )+D&t{{3D$Q'..,>3A6==k51d ? 7 19D0@9iLFD!D!DDB"k1sA+A3vhat1TF1#QGDaa00D&9$PTUB ''+V ())O MM!N!N!NLL --  
  MM$|n|ngllS,-  
" 
* )+D&t{{3D /q37L3MPQ3QR L  }$|$)&2OCeawawc%GGD+HC-cWAcWNKD!CHH$Cl$CCDAFF&9$PTUB ''+())#s   ?Ic              #     K   | D ]L  }|j                   dv r8dD ]2  }|j                  d|j                  |   |j                  |          4 I| N yw)z<Expand known 'superinstructions' into their component parts.)LOAD_FAST_LOAD_FAST!LOAD_FAST_BORROW_LOAD_FAST_BORROW)r   rh   r`   r  N)r&  r  r)  )r	  r.  rZ  s      r,   r  z/RewrittenInstructions._unpack_superinstructionsl  sq     
 ! 	D{{   " C--*#{{3/ $C 0 (   
	s   AAc                   t         sL| j                  t        j                  v r0| j	                  t        j                  | j                     d      } | S t
        r| j                  x}t        j                  v rPdt        j                  | j                     i}|dk(  rt        | j                        |d<    | j                  d
i |} | S |dk(  r"| j                  dk(  r| j	                  dd	      } | S )zFUpdate/modify specific instructions to simplify multi-version parsing.rp   )r  r&  r&  re   r  z[]rs   r   )r&  r  r*   )
r4   r&  r<   rS   r  r8   rf   r   r)  r  )r.  r&  updated_paramss      r,   r  z)RewrittenInstructions._update_instruction  s     dkkW^^;==t{{3" ! D"  ++%'*F*FF #+G,H,H,U!V--03DKK0@N9-$t}}6~6 	 ;&4<<4+?}}OR}Hr+   c                    | j                   st               | _         | j                   }|dk(  xr! |j                  |      t        j                  u xs |dk(  xr |j                  |      t        u S )Nr   rh   )r  r   r  r   )r  r   r   r  varss        r,   r  z)RewrittenInstructions._is_stdlib_datetime  sk     %%%>%@D"%%q QTXXm%<@Q@Q%QJ"Htxx'<'H	Jr+   N)r	  Iterator[Instruction]r  rw  r
  r  rx  ry  )rx  r    )rx  r  )r  r   rx  r   )
rZ  r    r  r   r  z5list[AbstractSet[Any] | dict[Any, Any] | None] | Noner  r   rx  rz  )r	  rz  rx  rz  )rZ  r    r  rz  rx  r    )r	  rz  rx  r  )r.  r   rx  r   )r   r   r   r   r  r    rx  r   )r&   r'   r(   r{  rt   r  r  r  r  r  r  r  r  r  r  r  r|  r  r  r  r*   r+   r,   r  r    s`    
	
LN+N 'N 0	N
 
N,122 (( (	(
 G( ( 
(T$6*"**.?*	*4cc.?c	cJP*P*.?P*	P*d '	 $  .J J/2JEHJ	Jr+   r  c                n   	 | j                   j                  }| j                  }|dk(  r|t        v rd| dfS |dk(  rj|t
        v rddt
        |    dfS |t        v r3dd	l}| t        ||      u r t        j                  d
| |      }d| dfS y|dk(  rdd	l}| |j                  u ryy# t        $ r Y yw xY w)zIIdentify translatable calls that aren't wrapped inside a lambda/function.)r   r   r   r   r  builtinsr  r%  r   Nr  r   r   )r   zstr.json_decode())	__class__r'   r&   AttributeErrorr   r   r   r   r  r   r  r   r   )r  func_modulerq  r   r  r   s         r,   _raw_function_metar	    s    ((33%%	
 g)/?"?	{"%%% 

	"))*;I*F)GqIII/)7433599I;'	 )B///  '!4::%23  s   "B( (	B43B4c                   |dk(  rd}t        |      |xr |d   }|s|dk7  ryt        j                  | |fx}      x}t        | |      }|t        |<   |j	                         r|j                  |       yt        |       \  }}|rI|rFt        |||      }	|	|_        | j                  }
|j                  ||	 d| |dk(  r|
n| d|
        yyy)	a  
    Generate `PolarsInefficientMapWarning` on poor usage of a `map` function.

    Parameters
    ----------
    function
        The function passed to `map`.
    columns
        The column name(s) of the original object; in the case of an `Expr` this
        will be a list of length 1, containing the expression's root name.
    map_target
        The target of the `map` call. One of `"expr"`, `"frame"`, or `"series"`.
    r.   z"TODO: 'frame' map-function parsingr   r   Nr   r  r_  )
r   r:   r  r  rB  ro  r	  r   r  r&   )r  columnsr   r   r   keyparsermodule
suggestionr^  fns              r,   warn_on_inefficient_mapr    s      W2!#&& %71:C3"9 *--h
5K.KcLLU*5'-$!!#C 09
j*3
JGK&1F#""BKK'2m1ZL$A#)Z#7Rxq=M  	 !6r+   r  )rx  zdict[str, Any])r   r   r   r   r   r   rx  r   )r  rw  rx  ztuple[str, str])r  rw  r  z	list[str]r   r0   rx  ry  )Pr{  
__future__r   r   rD  r   r   sysrn  bisectr   collectionsr   r   r   	itertoolsr   r	   pathlibr
   typingr   r   r   r   r   r   r   polars._utils.cacher   rk  r   r   collections.abcr   r   r   r   AbstractSetr   r   r   r   r0   r)   r   r1   version_infor4   r6   r8   r:   r<   rt   r   r   r   r   r   r   r   r   rc   r   rw   rn   r   r   compiler   r   r   r   r   r  rT  r  r	  r  __all__)kindunarys   00r,   <module>r!     s   T "  
  	 
   #    (    ) 7BB2 /# # 89	9 9j(
I ($$/
E />3#3#3w#>
E >>3#3#3w#>
E > RL   
9- 9-z *3*& : 09/I , I*3+ ' > %	, ( 	 , ( 
 +44E*F%*P ' P.. . %	.
 &. &. }. #. #. . . . [. I.  
8!." I#.$ ,%.& #'.( 1. * 8
Ye 
"  +L9:!++,-.*+  +L9:!++,z)*  +m_!++,z")  +m_+n-!++,#~%,"	  +m_+n-&-$../#T*+&<.%,"	[7+ ' 7t ,/w}}+=*>)C
& C " 	 /t.&..  #4 0  &2::&UV 5 V$"**%<= % ="

#45 5:#2F FRP' P'fQJ QJhB,",-6,DM,	,^ 6
7Us   L