
    ˀh@                       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 er.ddlmZ ddlm Z! ddlm"Z" ejF                  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jF                  dk\  Z+e+xr ejF                  dk\  Z, G d d      Z- e.d      Z/ e.d      Z0 e.d      Z1ddd d!d"d#d$d%d&Z2d'd(d)d*Z3 e.e3      d+hz  Z4d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;Z5d<d=hgg e-jl                  gg e0gg e1gd>d<d=hgg e-jl                  gg d?hgg e/gd>d<hgg e-jl                  gg d@hgg dAhgd>d<hgd=hge-jl                  gg dBhgg dChgdDdEd<hgd=hgdFhge-jl                  gdBdGhgdBhgdChgdDdEgZ7dHe(dI<   e7D  cg c]$  }  e8e-jr                        gg fD ]
  }i | dJ|i & c}} Z7dKdLdMdNdOdPdQdRZ: ejv                  dS      Z< ejv                  dT      Z=d`dUZ>dadVZ? G dW dX      Z@ G dY dZ      ZA G d[ d\      ZBdbd]ZC	 	 	 	 	 	 	 	 dcd^ZDdXd_gZEyc c}} w )dzNUtilities 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	re_escape)Iterator)Set)Instruction)   
   )	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#        n/var/www/html/wine-match-dev/backend/winematch-backend/venv/lib/python3.12/site-packages/polars/_utils/udfs.pyr   r   (   s#    M"K"r)   r   )exprframeseriesr   	MapTarget
StackEntry)r      )r      c                  v   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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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_TRUErP   rQ   CONTROL_FLOW)
LOAD_CONST
LOAD_DEREF	LOAD_FASTLOAD_GLOBALLOAD_METHOD	LOAD_ATTR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&   rJ   r'   	frozenset
_MIN_PY311rK   
_MIN_PY312rT   LOAD_VALUESrZ   LOADr]   rb   setPARSEABLE_OPSMATCHABLE_OPSvaluesUNARY_VALUESr(   r)   r*   r3   r3   7   sD   #!(F$  fX/=1QRD j *-(+$'#&		
 "% #$'#&	
 *   TUK=+67I"DQ+I'  'E# 
 L
e*	
l
	 i.	 		M "CK/);dBMU\\^,Lr)   r3   )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arctanhrx   ry   rz   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str.ends_withzstr.to_lowercasezstr.strip_chars_startzstr.strip_prefixzstr.strip_suffixstr.replacezstr.strip_chars_endstr.starts_withzstr.strip_charszstr.to_titlecasezstr.to_uppercasez	str.zfillzdt.datez
dt.weekdayzdt.time)endswithlowerlstripremoveprefixremovesuffixreplacerstrip
startswithstriptitleupperzfillr   
isoweekdaytimerW   rU   )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_globalrZ   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^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   r\   )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                v   d|  d}|dk(  r|S |dk(  rt        j                  d|      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-   z^(s|srs\d?|series)\..r\   r    )ssrsr-   z\br   zTODO: map_target = )rematchsplitr   searchr   nextNotImplementedError)col
expression
map_targetcol_exprsearch_exprnamer   msgs           r*   _get_target_namer   4  s    #b!HV	x	88+Z8##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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_namedict[str, Any] | None_caller_variablesc                    	 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__R  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_boolm  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.Nr\   )r   
ValueErrorlen
parametersr   r   keys)r   sigr  s      r*   r   zBytecodeParser._get_param_names  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).r\   r   ())r   opnamelistr  r   offsetargvalr3   rT   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                   duxrW t        | j                        dk\  xr= t        d | j                  D              xr t	        d | j
                  D              dk(  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  r3   rn   .0r  s     r*   	<genexpr>z5BytecodeParser.can_attempt_rewrite.<locals>.<genexpr>  s'       w444s   &(c              3  >   K   | ]  }|j                   d k(  rd  yw)RETURN_VALUEr\   N)r  r  s     r*   r  z5BytecodeParser.can_attempt_rewrite.<locals>.<genexpr>  s$      ;;.0 s   r\   )r   r   r   allsumr   r  s    r*   can_attempt_rewritez"BytecodeParser.can_attempt_rewrite  s}     D( D001Q6   88    66 
 	
r)   c                B    t        j                   | j                         y)z%Print disassembled function bytecode.N)disr   r  s    r*   r&  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                   d| _         | j                  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%        t'        |                  c c}}|      }	dj+                  d |	D              }
d|
vry| j-                  |
      }
| j                  d	k(  r;| j                   x}t/        ||
| j                        }|
j1                  d
| d|      S |
S c c}}w # t(        $ r Y yw xY w)zDTranslate postfix bytecode instructions to polars expression/string.Nr   r\   )r   r   r   r   )r   r+  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	  	enumerater   r  r3   rT   r
  appendr  r  InstructionTranslatorr   r   r   to_expressionr   boolr   joinr   r   r   )r   r   control_flow_blocksr  jump_offsetidxr  r
  opsexpression_stringspolars_exprtarget_names               r*   r7  zBytecodeParser.to_expression  s    $# *$/!"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'22;?K8+#'#8#88KA"23TEUEU"VK"**XcU"+={KK""= # 		s%   $F1 A&F+
(	F1 +F1 1	F=<F=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)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.variousrE  rF  polars.exceptionsrG  r7  r   r   r   r   r$   r   warningswarn)r   r   rB  rC  rE  rF  rG  suggested_expressionr@  	func_nameaddendumapitypeclsnamebeforeafters                  r*   rP  zBytecodeParser.warn  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   r.   returnNone)r+   r   rY  r   )r   rX  rY  r"   )r  zdict[int, str]r  list[Instruction]rY  zlist[tuple[int, str]])rY  r.   )rY  r8  )rY  rZ  )rY  rX  )rY  r[  )rY  r"   )r   r   rY  r"   )r   r   rB  r"   rC  r"   rY  rZ  )r$   r%   r&   __doc__r   r'   r   r   r   staticmethodr   r  propertyr   r$  r&  r   r   r+  r-  r7  rP  r(   r)   r*   r   r   L  s   W#'j'/3,3
6 
 
1)1 01 
	14    
2    I I     2 22#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)r6  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__D  s'     11,
K!1!r)   c                >    | j                  | j                  |||      S )z7Convert intermediate stack to polars expression string.)_exprrb  )r   r   r+  r/  s       r*   r7  z#InstructionTranslator.to_expressionO  s    zz$++sJ>>r)   c                   | j                   t        j                  v rt        j                  | j                      S | j                  r| j                  S | j                   dk(  r| j                  rdS dS | j                   dk(  r| j                  rdS dS | j                   t        j
                  v rt        j
                  | j                      S | j                   dk(  ryd	| j                    d
| }t        |      )z@Convert bytecode instruction to suitable intermediate op string.rc   is notisrf   not ininrg   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` expressions and the following instruction object:
)r  r3   rT   argreprr  rb   AssertionError)r  r   s     r*   opzInstructionTranslator.opS  s     ;;'...''44\\<<[[G##{{844[[M)#{{844[[GMM)==--[[O+# 7t{{m DF GKXO  !%%r)   c                   t        |t              r/t        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|d   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\1r\   r3  r  r   ()r   r   Nr  z).znp.r   math.)rg  rf  r  rZ  rg  not_z.is_znull())ri  rh  ri  r^   r0  z.is_in(z))rj  zrequire dict mappingr6   z * 2**z).cast(pl.Int64)r7   z / 2**r   r   )
isinstancer   _RE_STRIP_BOOLr   r   rd  r    r   r3   rq   r   r   r#   _NUMPY_MODULE_ALIASES_NUMPY_FUNCTIONS_MODULE_FUNC_TO_EXPR_NAMEget_MATH_FUNCTIONSr!   r   r   dictr   )r   valuer   r+  r/  rm  e1callpfxe2rq  r   r+   s                r*   rd  zInstructionTranslator._exprk  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))eAh&.@!#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-   r\   N_from_module)r   r   r    r!   r#   r  r  r   zTODO: z map target not yet supported.)r5  r  r3   rl   rk  rb   r]   rw  r   rm  popgetattrr   )r   r   r   stackr  r   s         r*   ra  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   r[  r   r   r   rX  r   r.   rY  rZ  )r   r   r+  r   r/  r   rY  r   )r  r   rY  r   )
rz  r/   r   r   r+  r   r/  r   rY  r   )r   r[  r   r.   rY  r/   )
r$   r%   r&   r\  r   r7  r]  rm  rd  ra  r(   r)   r*   r6  r6  A  sw    H	"'	" 0	" '		"
 	" 
	"? & &.BH#'-#';D#'	#'r)   r6  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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	  r)  _unpack_superinstructionsr  _ignored_opsr3   ro   r   _upgrade_instructionr5  _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 $ 9 9$ ?'..}=	> (,}}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__  s    D0011r)   c                     | j                   |   S r  )r   )r   items     r*   __getitem__z!RewrittenInstructions.__getitem__  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).
        r\   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>+  sK      7
 2m\ KK=( F%D)DF7
s   24)r   _instructionsr  r3   rK   r"  r	   )	r   r<  opnamesargvalsr  n_required_ops
idx_offsettrailing_instr   s	            r*   _matcheszRewrittenInstructions._matches  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   r\   c              3  4   K   | ]  } |      x  y wr  r(   )r  map_rewriter<  	incrementupdated_instructionss     r*   r  z1RewrittenInstructions._rewrite.<locals>.<genexpr>B  s)      	: *#/CDDD	:s   )r  r   r  r3   rl   any_rewrite_functions_rewrite_methods_rewrite_builtins_rewrite_attrsr5  )r   r   r  r<  r  r  s      @@@r*   r  zRewrittenInstructions._rewrite5  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.rW   rZ   NT)r  r  r  r\   r[   r  r  rk  r   )r  _PYTHON_ATTRS_MAPr  _replaceextendr   )r   r<  r  matching_instructionsr  	expr_namepxs          r*   r  z$RewrittenInstructions._rewrite_attrsP  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.rX   rW   rU   r  r  Nr  cast(pl.r  r[   r  r  rk  r
  r
  )
r  r3   rK   _PYTHON_BUILTINSr  _PYTHON_CASTS_MAPr  r
  r  r   )
r   r<  r  r  inst1inst2r  dtyper  operands
             r*   r  z'RewrittenInstructions._rewrite_builtinsa  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   rX   rV   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   rp  r[   r  Nr  )r   rw  r3   rK   r  r   r   r   r  r%   r  rv  _is_stdlib_datetimer  r
  r  r  )r   r<  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.rY   rU   r  r   r\   )r   r   starts)r=   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  r[   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>+  s     $CT!W$Cr  )rj   r3   rZ   r  rK   _PYTHON_METHODS_MAPr  r  rr  tupler9  r  r5  r   )r   r<  r  rY   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 ]M  }|j                   dk(  r8dD ]2  }|j                  d|j                  |   |j                  |          4 J| O yw)z<Expand known 'superinstructions' into their component parts.LOAD_FAST_LOAD_FAST)r   r\   rW   r  N)r  r  r  )r   r  r<  s      r*   r  z/RewrittenInstructions._unpack_superinstructions2  sk     
 ! 		D{{33! C--*#{{3/ $C 0 (   
		s   AAc                    t         sJ| j                  t        j                  v r.| j	                  t        j                  | j                     d      } | S )zCRewrite any older binary opcodes using py 3.11 'BINARY_OP' instead.rd   )rk  r  )ri   r  r3   rJ   r  )r  s    r*   r  z*RewrittenInstructions._upgrade_instructionB  sC     dkkW^^;==t{{3" ! D 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   r\   )r   r   rw  r   )r   r   r   r  varss        r*   r  z)RewrittenInstructions._is_stdlib_datetimeL  sk     %%%>%@D"%%q QTXXm%<@Q@Q%QJ"Htxx'<'H	Jr)   N)r   Iterator[Instruction]r   rX  r   r   rY  rZ  )rY  r   )rY  r  )r  r   rY  r   )
r<  r   r  zlist[AbstractSet[str]]r  z5list[AbstractSet[Any] | dict[Any, Any] | None] | Noner  r8  rY  r[  )r   r[  rY  r[  )r<  r   r  r[  rY  r   )r   r[  rY  r  )r  r   rY  r   )r   r   r   r   r  r   rY  r8  )r$   r%   r&   r\  rh   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   ro  builtinsr  r  r   Nrp  r   r   )r   zstr.json_decode())	__class__r%   r$   AttributeErrorru  r  rx  r   r  rv  rw  r   r   )r   func_modulerR  r   r  r   s         r*   _raw_function_metar  W  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                X   |dk(  rd}t        |      |xr |d   }|s|dk7  ry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 names 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  rA  )r   r   r$  rP  r  r   r   r$   )
r   columnsr   r   r   parsermodule
suggestionr@  fns
             r*   warn_on_inefficient_mapr  x  s    " W2!#&& %71:C3"9 Hj1F!!#C 09
j*3
JGK&1F#""BKK'2m1ZL$A#)Z#7Rxq=M  	 !6r)   r  )rY  zdict[str, Any])r   r   r   r   r   r   rY  r   )r   rX  rY  ztuple[str, str])r   rX  r  z	list[str]r   r.   rY  rZ  )Fr\  
__future__r   r   r&  r   r   sysrO  bisectr   collectionsr   r   r   	itertoolsr   r	   pathlibr
   typingr   r   r   r   r   r   r   rM  r   collections.abcr   r   AbstractSetr   version_infor   typing_extensionsr   r.   r'   r   r/   ri   rj   r3   rh   rx  rt  ru  r  r  r  r  rZ   r   rm   rb   rv  compiler   rs  r   r   r   r6  r   r  r  __all__)kindunarys   00r*   <module>r     s   T "  
  	 
   #    (    ,(2
7"$/# # 89	9 9c:o.
I .(
7C,,7
3- 3-n : "/2  > %	  (I ./5'9   %&&### 0  +L9:!++,-.*+  +L9:!++,z)*  +m_!++,z")  +m_+n-!++,#~%,"	  +m_+n-&-$../#T*+&<.%,"	[7> : 7x "w}}%&+ 	 /t.&..  #  BJJNO -.:#0r rjQ' Q'hJ JDB*"*-6*DM*	*Z 6
7Cs   <)I