
    .h7                       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r6ddl!m"Z"m#Z# ddl!m$Z% ddlm&Z& ddlm'Z' ejP                  dk\  rddlm)Z) nddl*m)Z)  G d de      Z+ed   Z,de-d<   ee.e+f   Z/de-d<   ejP                  dk\  Z0e0xr ejP                  dk\  Z1e1xr ejP                  dk\  Z2 ed      Z3de-d<    G d d       Z4 e5d!      Z6 e5d"      Z7 e5d#      Z8d$d%d&d'd(d)d*d+d,Z9d-d.d/d0Z: e5e:      d1hz  Z;i d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYZ<dZd[hgg e4jz                  gg e7gg e8gd\dZd[hgg e4jz                  gg d]hgg e6gd\dZhgg e4jz                  gg d^hgg d_hgd\dZhgd[hge4jz                  gg d`hgg dahgdbdcdZhgd[hgddhge4jz                  gd`dehgd`hgdahgdbdcgZ>dfe-dg<   e>D  cg c]$  }  e?e4j                        gg fD ]
  }i | dh|i & c}} Z>didjdkdldmdndodpZA ej                  dq      ZC ej                  dr      ZD ej                  ds      ZEddtZFdduZG G dv dw      ZH G dx dy      ZI G dz d{      ZJdd|ZK	 	 	 	 	 	 	 	 dd}ZLdwd~gZMy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CallableClassVarLiteral
NamedTupleUnion)LRUCache)
no_default	re_escape)IteratorMutableMapping)Set)Instruction)	NoDefault)   
   )	TypeAliasc                  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&        P/var/www/html/ai-service/venv/lib/python3.12/site-packages/polars/_utils/udfs.pyr   r   +   s#    M"K"r,   r   )exprframeseriesr   	MapTarget
StackEntry)r      )r      )r          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_TRUErV   rW   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)   rP   r*   	frozenset
_MIN_PY311rQ   
_MIN_PY312rZ   LOAD_VALUESr`   LOADrc   rf   rk   setPARSEABLE_OPSMATCHABLE_OPSvaluesUNARY_VALUESr+   r,   r-   r9   r9   ?   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,   r9   )acosacoshasinasinhatanatanhcbrtceilcoscoshdegreesexpfloorloglog10log1ppowradianssinsinhsqrttantanh)npnumpy)arccosarccosharcsinarcsinharctanarctanhr   r   r   r   r   r   r   r   r   r   r   signr   r   r   r   r   z	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yearFloat64Int64String)floatr!   r   abs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   r]   r[   )argument_1_opnameargument_2_opnamemodule_opnameattribute_opnamemodule_nameattribute_namefunction_namemathjsonloadsdatetimestrptimeF)r   r   r   r   r   r   r   check_load_globalr`   dtz'list[dict[str, list[AbstractSet[str]]]]_MODULE_FUNCTIONSargument_1_unary_opnamer   r   r   r   r   r   str.json_decode)z	math.acosz
math.acoshz	math.asinz
math.asinhz	math.atanz
math.atanhz
json.loadsz,pl\.col\("([^"]*)"\) & pl\.col\("\1"\)\.(.+)z^(s|srs\d?|series)\.z^bool\((.+)\)$c                 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   re   )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.   r0   .re   r    )ssrsr0   z\br   zTODO: map_target = )	_RE_SERIES_NAMESmatchsplitr   researchr   nextNotImplementedError)col
expression
map_targetcol_exprsearch_exprnamer   msgs           r-   _get_target_namer   J  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__k  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)_RE_IMPLICIT_BOOLr   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.Nre   )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).re   r   ())r  opnamelistr  r   offsetargvalr9   rZ   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  r9   rw   .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_VALUEre   N)r  r*  s     r-   r,  z5BytecodeParser.can_attempt_rewrite.<locals>.<genexpr>  s$      {{n4 s   re   )r   r   r  r  allsumr  r$  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   r$  s    r-   r3  zBytecodeParser.dis  s    r,   c                    | j                   S )zThe function being parsed.)r   r$  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_instructionsr$  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   r$  s    r-   
param_namezBytecodeParser.param_name  r%  r,   c                ,    t        | j                        S )zEThe rewritten bytecode instructions from the function we are parsing.)r  r  r$  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   re   )r   r   r   r   )r   r8  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(r0   )r   r   r   r	  r   r   r   r   r  	enumerater  r  r9   rZ   r  appendr"  r  InstructionTranslatorr   r   r   to_expressionr!   boolr   joinr
  r   r   )r  r   col_namer.   control_flow_blocksr  jump_offsetidxr  r  opsexpression_stringspolars_exprtarget_names                 r-   rD  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}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   )find_stacklevel in_terminal_that_supports_colour)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)r0   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.variousrS  rT  polars.exceptionsrU  rD  r   r   r   r   r'   r   warningswarn)r  r   rP  rQ  rS  rT  rU  suggested_expressionrN  	func_nameaddendumapitypeclsnamebeforeafters                  r-   r^  zBytecodeParser.warn0  ss   	
 	B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   r1   returnNone)r.   r   rg  r   )r   rf  rg  r%   )r  zdict[int, str]r  list[Instruction]rg  zlist[tuple[int, str]])rg  r1   )rg  rE  )rg  rh  )rg  rf  )rg  ri  )rg  r%   )r   r   rg  r%   )r   r   rP  r%   rQ  r%   rg  rh  )r'   r(   r)   __doc__r   r*   r   r   r   r   r  r
  staticmethodr   r"  propertyr   r1  r3  r   r  r8  r:  rD  r^  r+   r,   r-   r   r   c  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)rC  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__o  s'     11,
K!1!r,   c                >    | j                  | j                  |||      S )z7Convert intermediate stack to polars expression string.)_exprrp  )r  r   r8  r<  s       r-   rD  z#InstructionTranslator.to_expressionz  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.rl   is notisro   not ininrp   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  r9   rZ   argreprr  rk   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\1re   r@  r  r   ()r   r   Nr  z).znp.r   math.)ru  rt  rh  ru  not_z.is_znull())rw  rv  rw  rg   r=  z.is_in(z))rx  zrequire dict mappingr<   z * 2**z).cast(pl.Int64)r=   z / 2**r   r   )
isinstancer   _RE_STRIP_BOOLr	  r    rr  r#   r"   r9   rz   r   r   r&   _NUMPY_MODULE_ALIASES_NUMPY_FUNCTIONS_MODULE_FUNC_TO_EXPR_NAMEget_MATH_FUNCTIONSr$   r   r   dictr   )r  valuer   r8  r<  r{  e1callpfxe2r  r   r.   s                r-   rr  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.   r0   re   N_from_module)r    r"   r#   r$   r&   r'  r  r   zTODO: z map target not yet supported.)rB  r  r9   ru   ry  rk   rf   r  r   r{  popgetattrr   )r  r   r   stackr  r   s         r-   ro  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   ri  r   r   r   rf  r   r1   rg  rh  )r   r   r8  r   r<  r!   rg  r   )r  r   rg  r   )
r  r2   r   r   r8  r   r<  r!   rg  r   )r   ri  r   r1   rg  r2   )
r'   r(   r)   rj  r  rD  rk  r{  rr  ro  r+   r,   r-   rC  rC  l  sw    H	"'	" 0	" '		"
 	" 
	"? & &.AF#'-#';D#'	#'r,   rC  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  r6  _unpack_superinstructionsr  _ignored_opsr9   rx   r  _update_instructionrB  _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  r$  s    r-   __len__zRewrittenInstructions.__len__-  s    4//00r,   c                ,    t        | j                        S r)  )r   r  r$  s    r-   __iter__zRewrittenInstructions.__iter__0  s    D0011r,   c                     | j                   |   S r)  )r  )r  items     r-   __getitem__z!RewrittenInstructions.__getitem__3  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).
        re   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>V  sK      7
 2m\ KK=( F%D)DF7
s   24)r  _instructionsr  r9   rQ   r/  r	   )	r  rJ  opnamesargvalsr  n_required_ops
idx_offsettrailing_instr   s	            r-   _matcheszRewrittenInstructions._matches6  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   re   c              3  4   K   | ]  } |      x  y wr)  r+   )r+  map_rewriterJ  	incrementupdated_instructionss     r-   r,  z1RewrittenInstructions._rewrite.<locals>.<genexpr>m  s)      	: *#/CDDD	:s   )r  r  r  r9   ru   any_rewrite_functions_rewrite_methods_rewrite_builtins_rewrite_attrsrB  )r  r   r  rJ  r  r  s      @@@r-   r  zRewrittenInstructions._rewrite`  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]   r`   NT)r  r  r  re   rd   r  r  ry  r   )r  _PYTHON_ATTRS_MAPr  _replaceextendr  )r  rJ  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.r^   r]   r[   r  r  Nr'  cast(pl.r  rd   r  r  ry  r  r  )
r  r9   rQ   _PYTHON_BUILTINSr  _PYTHON_CASTS_MAPr  r  r  r  )
r  rJ  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   r^   r\   r   r   r   r   r   r   r   r   r  r   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~  rd   r  Nr  )r   r  r9   rQ   r  r  r   r   r  r(   r  r  _is_stdlib_datetimer  r  r  r  )r  rJ  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.r_   r[   r  r   re   )r   r   starts)rC   r   )r   $r@   c              3  2   K   | ]  }t        |        y wr)  )r   r+  vs     r-   r,  z9RewrittenInstructions._rewrite_methods.<locals>.<genexpr>)  s     !D1)A,!D   '"zstr.contains(rr  r  rd   r  r   r   ,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>V  s     $CT!W$Cr  )rs   r9   r`   r  rQ   _PYTHON_METHODS_MAPr  r  r  tuplerF  r  rB  r  )r  rJ  r  r_   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   re   r]   r  N)r  r  r  )r   r  rJ  s      r-   r  z/RewrittenInstructions._unpack_superinstructions]  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.rm   )ry  r  r  rb   ry  z[]rp   r   )r  ry  r+   )
rr   r  r9   rP   r  
_MIN_PY314rc   r   r  ry  )r  r  updated_paramss      r-   r  z)RewrittenInstructions._update_instructionp  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   re   )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   rf  r   r   rg  rh  )rg  r!   )rg  r  )r  r   rg  r   )
rJ  r!   r  zlist[AbstractSet[str]]r  z5list[AbstractSet[Any] | dict[Any, Any] | None] | Noner  rE  rg  ri  )r   ri  rg  ri  )rJ  r!   r  ri  rg  r!   )r   ri  rg  r  )r  r   rg  r   )r   r   r   r   r  r!   rg  rE  )r'   r(   r)   rj  rq   r  r  r  r  r  r  r  r  r  r  r  rk  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_moduler`  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  rO  )
r   r7   r  r   r1  r^  r  r   r   r'   )r   columnsr   r   r   keyparsermodule
suggestionrN  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
  )rg  zdict[str, Any])r   r   r   r   r   r   rg  r   )r   rf  rg  ztuple[str, str])r   rf  r  z	list[str]r   r1   rg  rh  )Nrj  
__future__r   r   r3  r   r   sysr]  bisectr   collectionsr   r   r   	itertoolsr   r	   pathlibr
   typingr   r   r   r   r   r   r   polars._utils.cacher   r[  r   r   collections.abcr   r   r   AbstractSetr   r   version_infor   typing_extensionsr   r1   r*   r   r2   rr   rs   r  r7   r9   rq   r  r  r  r  r  r  r  r`   r   rv   rk   r  compiler  r   r  r   r   r   rC  r   r  r
  __all__)kindunarys   00r-   <module>r     s   T "  
  	 
   #    (    ) 782/
7"$/# # 89	9 9c:o.
I .(
7C,,7
7C,,7
 RL   
9- 9-z : "/2  > %	  (I ./5'9   %	
 & & } # #    [ I  
8!" I#$ ,%& #'( 1 >  +L9:!++,-.*+  +L9:!++,z)*  +m_!++,z")  +m_+n-!++,#~%,"	  +m_+n-&-$../#T*+&<.%,"	[7> : 7x "w}}%&+ 	 /t.&..  #  BJJNO 2::56 -.:#2F FRP' P'fQJ QJhB,",-6,DM,	,^ 6
7Us   )J?