
    q-Ph@                    6   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j#        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j#        dk    Z+e+o
ej#        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-j6        gg e0gg e1gd>d<d=hgg e-j6        gg d?hgg e/gd>d<hgg e-j6        gg d@hgg dAhgd>d<hgd=hge-j6        gg dBhgg dChgdDdEd<hgd=hgdFhge-j6        gdBdGhgdBhgdChgdDdEgZ7dHe(dI<   dJ e7D             Z7dKdLdMdNdOdPdQdRZ8 ej9        dS          Z: ej9        dT          Z;dldWZ<dmd\Z= G d] d^          Z> G d_ d`          Z? G da db          Z@dndfZAdodjZBd^dkgZCdS )pzNUtilities 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                  F    e Zd ZU ded<   ded<   ded<   ded<   dZded	<   dS )

StackValuestroperatorintoperator_arityleft_operandright_operandN
str | Nonefrom_module)__name__
__module____qualname____annotations__r#        R/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/polars/_utils/udfs.pyr   r   (   sP         MMM"K""""""r)   r   )exprframeseriesr   	MapTarget
StackEntry)r      )r      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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                                          Zd!S )"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   s        #!( (F     9QfXX/=1QRRD 	
 )	
),(+$'#&		
 	
 	
 "% #$'#&	
 
       )TUUK	=+677I"DQ+I     ' 'E    
 ILLL
#e**	
#l

	 #i..	 		 M "CCKK/);dBM9U\\^^,,LLLr)   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_FUNCTIONSc                \    g | ])}t          t          j                  gg fD ]
}i |d |i*S )argument_1_unary_opname)rm   r3   rb   ).0kindunarys      r*   
<listcomp>r     sa       w}%%&+  	 /t.&..   r)   r   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\((.+)\)$returndict[str, Any]c                 8   t          t                    j        j        } t          j                    }d}	 |rFt          j        |          }|                    t          |                     r|j        }|dz  }nn|F|i }ni |j	        |j
        }~n# ~w xY w|S )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    8nn#*G  ""E	A 	OE**EG-- Q  	 =II=5>=U_=I EE				s   AB Bcolr   
expression
map_targetc                   d|  d}|dk    r|S |dk    rt          j        d|          r|                    dd          d         S |                    |d	          }d
D ]}t          j        d| d|          s|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\bTr   zTODO: map_target = )rematchsplitr   searchr   nextNotImplementedError)r   r   r   col_exprsearch_exprnamer   msgs           r*   _get_target_namer   4  s   !#!!!HV	x		8+Z88 	/##C++A.. !((266* 	 	D9^4^^^[99 GG	"a??D9^4^^^[9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d0d!Zddd"d1d%ZdS )2BytecodeParserzMIntrospect UDF bytecode and determine if we can rewrite as native expression.Nr"   _map_target_namedict[str, Any] | None_caller_variablesfunctionCallable[[Any], Any]r   r.   r   Nonec                    	 t          |          }n# t          $ r t          g           }Y nw xY w|| _        || _        |                     |          | _        t          || j        |          | _	        dS )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_variablesr   N)
r   	TypeErroriter	_function_map_target_get_param_name_param_nameRewrittenInstructionsr   _rewritten_instructions)selfr   r   original_instructionss       r*   __init__zBytecodeParser.__init__R  s    	-$4X$>$>!! 	- 	- 	- %)HH!!!	-
 "%//99'<.!3(
 (
 (
$$$s    ..r+   r   c                    t                               |          r6t                               d|          }t                               |          6|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  sP    &&t,, 	O$((.@(NND  &&t,, 	Or)   c                    	 t          |           }n# t          $ r Y dS w xY wt          |j        x}          dk    r.t	          t          |                                                    ndS )z&Return single function parameter name.Nr\   )r   
ValueErrorlen
parametersr   r   keys)r   sigr
  s      r*   r   zBytecodeParser._get_param_names  s~    	H%%CC 	 	 	44	 /:00A55 joo''(()))	
s    
  expression_blocksdict[int, str]logical_instructionslist[Instruction]list[tuple[int, str]]c                   |rt          d |D                       dk    rt          |                                          }d}|D ]v}|t          ||j                  dz
           }|t          ||j                  dz
           }|dk    r||d         k    s&|||fvr d||         z   ||<   ||xx         dz  cc<   |}w|D ]!}t          j        |j                 ||j        <   "t          |
                                          S )zBInject nesting boundaries into expression blocks (as parentheses).c                    h | ]	}|j         
S r(   opnamer   insts     r*   	<setcomp>z1BytecodeParser._inject_nesting.<locals>.<setcomp>  s    AAADDKAAAr)   r\   r   ())r	  listr  r   offsetargvalr3   rT   r  sorteditems)r   r  r  block_offsetsprev_endr  startends           r*   _inject_nestingzBytecodeParser._inject_nesting  s=      	S AA,@AAABBQFF+/0A0F0F0H0H+I+I0 + +D)+mT[*Q*QTU*UVE'M4;(O(ORS(STC!QJJ3-2C+C+C#E3<777:=Nu=U7U-e4-c222c9222'*H, S S181Edk1R!$+..'--//000r)   c                    | j         S )z8The map target, eg: one of 'expr', 'frame', or 'series'.)r   r   s    r*   r   zBytecodeParser.map_target       r)   boolc                    | j         duoWt          | j                  dk    o?t          d | j        D                       o!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  <   K   | ]}|j         t          j        v V  d S N)r  r3   rn   r  s     r*   	<genexpr>z5BytecodeParser.can_attempt_rewrite.<locals>.<genexpr>  s@         w44     r)   c              3  0   K   | ]}|j         d k    dV  dS )RETURN_VALUEr\   Nr  r  s     r*   r.  z5BytecodeParser.can_attempt_rewrite.<locals>.<genexpr>  s;        ;.00 0000 r)   r\   )r   r	  r   allsumr   r'  s    r*   can_attempt_rewritez"BytecodeParser.can_attempt_rewrite  s     D( D011Q6    8        6    
 	
r)   c                8    t          j         | j                   dS )z%Print disassembled function bytecode.N)disr   r'  s    r*   r5  zBytecodeParser.dis  s    r)   c                    | j         S )zThe function being parsed.)r   r'  s    r*   r   zBytecodeParser.function  s     ~r)   c                4    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GH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111r)   r   c                   	 d _          j        dS t          t                    }g 	d}t	           j                  D ]^\  }}|j        t          j        v r+ j        |dz            j	        }	
                    |           C||         
                    |           _	                      	 fd|                                D             	          }n# t          $ r Y dS w xY wd                    d |D                       }d|vrdS                      |          } j        dk    r9 j         x}t#          | j                  }|                    d	 d
|          S |S )zDTranslate postfix bytecode instructions to polars expression/string.Nr   r\   c                    i | ]]\  }}|t          |j        j        j                                       j        t          t                                        ^S ))r   r   r   r   )r   r:  depth)InstructionTranslatorr   r   r   to_expressionr   r   r)  )r   r  opsr   r  r   s      r*   
<dictcomp>z0BytecodeParser.to_expression.<locals>.<dictcomp>  s        $ 1%()-)?#'#3!%	  
 $m#'#3!$';"<"<== $    r)    c              3      K   | ]	\  }}|V  
d S r-  r(   )r   _offsetr+   s      r*   r.  z/BytecodeParser.to_expression.<locals>.<genexpr>  s&      LLtLLLLLLr)   pl.col(r-   r   r   )r   r   r   r  	enumerater   r  r3   rT   r  appendr%  r   r   joinr  r   r   r   )
r   r   control_flow_blocksjump_offsetidxr  expression_stringspolars_exprtarget_namer  s
   ``       @r*   rA  zBytecodeParser.to_expression  s    $#4 *$//!"4#?@@ 	> 	>IC{g222":37CJ$++D1111#K077====	!%!5!5      (;'@'@'B'B   %" "  # 	 	 	44	hhLL9KLLLLL K''422;??K8++#'#88KA"23TEU"V"VK"**+=c+=+=+={KKK""s    6C 
C%$C%suggestion_overrideudf_overriderR  rS  c          
        ddl m}m} ddlm} |p|                     |          }|| j        x}t          ||| j                  }|p| j	        j
        p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| | |                       dS dS )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.variousrU  rV  polars.exceptionsrW  rA  r   r   r   r   r$   r   warningswarn)r   r   rR  rS  rU  rV  rW  suggested_expressionrP  	func_nameaddendumapitypeclsnamebeforeafters                  r*   r`  zBytecodeParser.warn  s   	
 	
 	
 	
 	
 	
 	
 	
 	BAAAAA2Md6H6H6M6M+#44=.-t/?  %H(?H5IJ&&=d&6===	  #777 [Z  #v-- (') GW 4355	S;SSiSSSL#7LL(LL  E;DDiDDD=/==8== FE MW  T[    
   ,*?,,	 	 	 	 	 	= ,+r)   )r   r   r   r.   r   r   )r+   r   r   r   )r   r   r   r"   )r  r  r  r  r   r  )r   r.   )r   r)  )r   r   )r   r   )r   r  )r   r"   )r   r   r   r"   )r   r   rR  r"   rS  r"   r   r   )r$   r%   r&   __doc__r   r'   r   r   r  staticmethodr   r%  propertyr   r3  r5  r   r   r:  r<  rA  r`  r(   r)   r*   r   r   L  s        WW#'''''/33333
 
 
 
6    
 
 
 \
1 1 1 14       X 
 
 
 
2           X I I I XI       X  2 2 2 X22# 2# 2# 2#p +/#'9 9 9 9 9 9 9 9r)   r   c                  J    e Zd ZdZddZddZedd            ZddZddZ	dS ) r@  z>Translates Instruction bytecode to a polars expression string.r   r  r   r   r   r   r   r.   r   r   c                X    |                      ||          | _        || _        || _        d S r-  )_to_intermediate_stack_stackr   r   )r   r   r   r   r   s        r*   r   zInstructionTranslator.__init__D  s.     11,
KK!1!r)   r   r   r:  r?  r   c                <    |                      | j        |||          S )z7Convert intermediate stack to polars expression string.)_exprrn  )r   r   r:  r?  s       r*   rA  z#InstructionTranslator.to_expressionO  s    zz$+sJ>>>r)   r  r   c                p   | j         t          j        v rt          j        | j                  S | j        r| j        S | j         dk    r| j        rdndS | j         dk    r| j        rdndS | j         t          j        v rt          j        | j                  S | j         dk    rdS 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###{4884[M))#{4884[GM))=--[O++##Ot{ O O GKO O  !%%%r)   valuer/   c                   t          |t                    rHt                              d|j                  }|                     |j        |||dz             }|j        dk    r|t          j	        vr|
                    d          r"|                    d          rdnd}| d| | S |d         t          j	        v r@|dd	         
                    d          r#|                    d          rdnd}d
| d| | S |j        t          v r|t          v rd}n5|j        dk    r(t                              d| |          t"          v rd}nd}| | d
| dS | | S |                     |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n	|
 | d|	 dS |dk    rd| j        st)                      | _        t          | 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n|S ||k    rd#| d$S |S )%z?Take stack entry value and convert to polars expression string.z\1r\   rG  r  r   ()r   r   Nr  z).znp.r   math.)rs  rr  r+  r   rs  not_z.is_znull())ru  rt  ru  r^   rD  z.is_in(z))rv  zrequire dict mappingr6   z * 2**z).cast(pl.Int64)r7   z / 2**r   r   )
isinstancer   _RE_STRIP_BOOLr  r   rp  r    r   r3   rq   r   r   r#   _NUMPY_MODULE_ALIASES_NUMPY_FUNCTIONS_MODULE_FUNC_TO_EXPR_NAMEget_MATH_FUNCTIONSr!   r   r   dictr   )r   rz  r   r:  r?  ry  e1callpfxe2r~  r   r+   s                r*   rp  zInstructionTranslator._exprk  s}   eZ(( >	&##E5>::BE.ZKKB#q((W111}}Y// 2%'[[%5%5?rr4"$11r14111!u 444ABB9J9J99U9U4%'[[%5%5?rr432333T333
 )-BBB"222#)V33599,",,KK*+ + & !-2------{b{{"ZZ 3S*eaiPP)))eAh&.@.@!#t22D 22d2222+++!#t22D "99  33"33R3333 $6b66666
 +++1 M1J1L1L.%d&<&@&@T&J&JDQQ 741#666 --2------4ZZ
 >r======4ZZ=r====== ,,2,,,,D*/9;t;;;;T9j  %c%%%%r)   c                p   |dv rg }|D ]}|                     |j        t          j        v r|j        n|j        t          j        v s(t          j                            |j                  dk    rHt          | 	                    |          d|
                                dt          |dd                    n[t          | 	                    |          d|
                    d          |
                    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.)rI  r  r3   rl   rw  rb   r]   r  r   ry  popgetattrr   )r   r   r   stackr  r   s         r*   rm  z,InstructionTranslator._to_intermediate_stack  sE    +++&(E$  {gl22 LL !K7=88&044T[AAQFF #%)WWT]]+,).*.(/nd(K(K    (%)WWT]]+,).2*/))B--(/nd(K(K     0 8O DzCCC!#&&&r)   N)
r   r  r   r   r   r   r   r.   r   r   )r   r   r:  r   r?  r   r   r   )r  r   r   r   )
rz  r/   r   r   r:  r   r?  r   r   r   )r   r  r   r.   r   r/   )
r$   r%   r&   rh  r   rA  ri  ry  rp  rm  r(   r)   r*   r@  r@  A  s        HH	" 	" 	" 	"? ? ? ? & & & \&.B B B BH#' #' #' #' #' #'r)   r@  c                      e Zd ZdZ eg d          Zd-dZd.dZd/dZd0dZ	ddd1dZ
d2dZd3d Zd3d!Zd3d"Zd3d#Zed4d$            Zed5d&            Zd6d+Zd,S )7r   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RESUMEr0  TO_BOOLr   Iterator[Instruction]r   r   r   r   r   r   c                f   || _         || _        t          |          | _        g }|                     | j                  D ]W}|j        | j        vrG|j        t          j        vr
g | _	         d S | 
                    |          }|                    |           X|                     |          | _	        d S r-  )r   r   r  r8  _unpack_superinstructionsr  _ignored_opsr3   ro   r   _upgrade_instructionrI  _rewrite)r   r   r   r   normalised_instructionsr  upgraded_insts          r*   r   zRewrittenInstructions.__init__  s     "!1&*<&8&8#"$2243NOO 	> 	>D{$"333;g&;;;35D0FF $ 9 9$ ? ?'..}==='+}}5L'M'M$$$r)   r   c                *    t          | j                  S r-  )r	  r   r'  s    r*   __len__zRewrittenInstructions.__len__  s    4/000r)   c                *    t          | j                  S r-  )r   r   r'  s    r*   __iter__zRewrittenInstructions.__iter__  s    D0111r)   itemr   r   c                    | j         |         S r-  )r   )r   r  s     r*   __getitem__z!RewrittenInstructions.__getitem__  s    +D11r)   F)is_attrrM  opnameslist[AbstractSet[str]]argvals5list[AbstractSet[Any] | dict[Any, Any] | None] | Noner  r)  r  c               0   t          |          |pg }}||z   }|r/| 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  J   K   | ]\  }}}|j         |v o|d u p|j        |v V  d S r-  )r  r  )r   r  match_opnamesmatch_argvals       r*   r.  z1RewrittenInstructions._matches.<locals>.<genexpr>+  s_       7
 7
 2m\ K=( F%D)D7
 7
 7
 7
 7
 7
r)   )r	  _instructionsr  r3   rK   r1  r	   )	r   rM  r  r  r  n_required_ops
idx_offsettrailing_instr   s	            r*   _matcheszRewrittenInstructions._matches  s    , #&g,,2>)
	"&"4Z*q.5P"QQ	 a '7<77I)#j.9|..3 7
 7
 6Agw6 67
 7
 7
 4
 4
.  	r)   c                j   || _         g dt          | j                   k     r| j                  dc}|j        t          j        vs5t          fd| j        | j        | j        | j	        fD                       s
                    |           pdz  t          | j                   k     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V  d S r-  r(   )r   map_rewriterM  	incrementupdated_instructionss     r*   r.  z1RewrittenInstructions._rewrite.<locals>.<genexpr>B  sI       	: 	: *k#/CDDD	: 	: 	: 	: 	: 	:r)   )r  r	  r  r3   rl   any_rewrite_functions_rewrite_methods_rewrite_builtins_rewrite_attrsrI  )r   r   r  rM  r  r  s      @@@r*   r  zRewrittenInstructions._rewrite5  s     *24C*++++"05qOD){',..c 	: 	: 	: 	: 	: 	: +)*'$	: 	: 	: 	7 	7. %++D1119>!C C*++++ $#r)   r  c                
   |                      |dhdhgdt          gd          x}rO|d         }t          |j                 }|                    d||          }|                    |d	         |g           t          |          S )
zDReplace python attribute lookup with synthetic POLARS_EXPRESSION op.rW   rZ   NT)r  r  r  r\   r[   r  r  rw  r   )r  _PYTHON_ATTRS_MAPr  _replaceextendr	  )r   rM  r  matching_instructionsr  	expr_namepxs          r*   r  z$RewrittenInstructions._rewrite_attrsP  s    $(MM!][M2,-	 %2 %
 %
 
  	H )+D)$+6I*9i   B !'')>q)A2(FGGG()))r)   c                   |                      |dhddht          j        gt          g          x}r|dd         \  }}|j        x}t
          v rt
          |         }d| d}|                    d	|||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  rw  r  r  )
r  r3   rK   _PYTHON_BUILTINSr  _PYTHON_CASTS_MAPr  r  r  r	  )
r   rM  r  r  inst1inst2r  dtyper  operands
             r*   r  z'RewrittenInstructions._rewrite_builtinsa  s     %)MM#_{L&A7<P%& %2 %
 %
 
  	7
 1!4LE5,&+<<<)&1,E,,,*|	    B nnELn99G ''"666()))r)   c           	     p   dD ]}t           D ]}|r|                    dd          s  dS |r)ddhg|d         |d         |d	         t          j        n8ddhg|d
         |d         |d         |d         |d	         t          j        }|d         }|                     |||r
g |d         ng |d         |d         |d                   x}rt          |d                   }||d|z            \  }	}
}|r|| j        st                      | _        |	j        x}| j        vr| j        |         j	        t          fd|D                       sMt                               d| |          }n|	j        dk    rd}n|	j        dk    rQ||dz            j        }d| d}|                     |	j        |d         j        |          st          |          c c S n;|	j        dk    r)t                              d|
j         |
j                  }n|
j        }|r|
n|}|	                    d|||j                  }|rdn|	j        pd|_        |                    |	j                  }|                    |d         r||d|z            |fn||f           t          |          c c S dS )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 V  	d S r-  r(   )r   mr   s     r*   r.  z;RewrittenInstructions._rewrite_functions.<locals>.<genexpr>  s(      &R&Raq(8&R&R&R&R&R&Rr)   r   r   r   r   zstr.to_datetime(format="r   r   r}  r[   r  Nr  )r   r  r3   rK   r  r	  r   r   r  r%   r  r  _is_stdlib_datetimer  r  r  r  )r   rM  r  check_globalsfunction_kindr  module_aliasesr  attribute_countr  r  inst3r  fmt	swap_instr  r  r   s                    @r*   r  z(RewrittenInstructions._rewrite_functions{  s&    + ]	6 ]	6M!2 \6 \6  ):):;NPT)U)U 111 %&5&':; ''@A '':;	
    '5&7 ''9: '':;	
 ''@A '':;   & "/}!=,0MM# % &7 &}5&'78 '7 -: - - ( D6 '*-8H*I&J&JO*?'!o*==+'E5% % 1#5 Q5N5P5PD2).5Id>TTT$*.*@*K*VK#&&R&R&R&R>&R&R&R#R#R ) ((A(E(E#. < < < <i) )II //$5		333Oa4GHO$Fs$F$F$F	#77!L1!4;+    > $''<#=#======> //$=$A$A2EL22EL% %		 %*L	 *7 AEI2( )(/	 (  B /<&Wdd%,BVRVBO'000EEG(// ))BC+#1!o2EF  &r]   45555555ID61\6| qr)   c           	        t           rt          j        ndh}|                     ||dht          j        gt
          g          p)|                     ||t          j        gt
          g          x}r|d         }t
          |j                 }|d         j        dk    rr|d         j        }t          |t                    rG|dv rCd|v rdnd	\  }}	d

                    d |D                       }
d|v rdnd}d| | d|
 d|	 | d	}n	|d|dz  }|                    d||          }|                    |           n/|                     ||dhdhdht          j        gt
          g          p-|                     ||dhdht          j        gt
          g          x}r|d         }t
          |j                 }d |dt          |          dz
           D             }|dk    r8t          |          dk    r|\  }}}|d|d|d| dz  }n5|\  }}d|d|d}n&|dd
                    d |D                        dz  }|                    d||          }|                    |           t          |          S )z@Replace python method calls with synthetic POLARS_EXPRESSION op.rY   rU   r  r   r\   )r   r   starts)r=   r   )r   $r:   c              3  4   K   | ]}t          |          V  d S r-  r   r   vs     r*   r.  z9RewrittenInstructions._rewrite_methods.<locals>.<genexpr>  s(      !D!D1)A,,!D!D!D!D!D!Dr)   '"zstr.contains(rr  r  r[   r  c                    g | ]	}|j         
S r(   )r  )r   is     r*   r   z:RewrittenInstructions._rewrite_methods.<locals>.<listcomp>  s*          r)   r   r   ,z,n=z,literal=True)zstr.replace_all(c              3  4   K   | ]}t          |          V  d S r-  )reprr  s     r*   r.  z9RewrittenInstructions._rewrite_methods.<locals>.<genexpr>+  s(      $C$CT!WW$C$C$C$C$C$Cr)   )rj   r3   rZ   r  rK   _PYTHON_METHODS_MAPr  r  r  tuplerJ  r  rI  r	  )r   rM  r  rY   r  r  r+   param_valuer  endsrxqr  param_valuesoldnewr   s                    r*   r  z&RewrittenInstructions._rewrite_methods  sT    ,6Jg''M? MM$|nglC,-     MM$gl3,-   
  I	, )+D&t{3D$Q'.,>>3A6=k511 	1d ? 7 7 19D0@0@99iLFD!D!D!D!D!DDDB"k11sAGAGvGGGGTG1GGGDD00000D&9$PTUUB ''++++ MM!N!N!NL --  
 
  MM$|n|nglS,-   
" '	,* )+D&t{3D .q37L3M3MPQ3Q/QR  L }$$|$$))&2OCeGGGGG%GGGGDD+HCKcKKcKKKDDFCHH$C$Cl$C$C$CCCFFFF&9$PTUUB ''+++()))r)   c              #     K   | D ]G}|j         dk    r6dD ]2}|                    d|j        |         |j        |                   V  3C|V  HdS )z<Expand known 'superinstructions' into their component parts.LOAD_FAST_LOAD_FAST)r   r\   rW   r  N)r  r  r  )r   r  rM  s      r*   r  z/RewrittenInstructions._unpack_superinstructions2  s      
 ! 		 		D{333!  C--*#{3/ $C 0 (       



		 		r)   r  c                    t           s?| j        t          j        v r,|                     t          j        | j                 d          } | S )zCRewrite any older binary opcodes using py 3.11 'BINARY_OP' instead.rd   )rw  r  )ri   r  r3   rJ   r  )r  s    r*   r  z*RewrittenInstructions._upgrade_instructionB  sH      	dkW^;;==t{3" !  D r)   r   r   r   r  c                    | j         st                      | _         | j         }|dk    o |                    |          t          j        u p!|dk    o|                    |          t          u S )Nr   r\   )r   r   r  r   )r   r   r   r  varss        r*   r  z)RewrittenInstructions._is_stdlib_datetimeL  sq     % 	A%>%@%@D"%q QTXXm%<%<@Q%QJ"Htxx'<'<'H	Jr)   N)r   r  r   r   r   r   r   r   )r   r   )r   r  )r  r   r   r   )
rM  r   r  r  r  r  r  r)  r   r  )r   r  r   r  )rM  r   r  r  r   r   )r   r  r   r  )r  r   r   r   )r   r   r   r   r  r   r   r)  )r$   r%   r&   rh  rh   r  r   r  r  r  r  r  r  r  r  r  ri  r  r  r  r(   r)   r*   r   r     s         9		
 		
 		
 LN N N N,1 1 1 12 2 2 22 2 2 2 ( ( ( ( ( (T$ $ $ $6* * * *"* * * *4c c c cJP* P* P* P*d    \    \J J J J J Jr)   r   r   r   tuple[str, str]c                v   	 | j         j        }| j        }n# t          $ r Y dS w xY w|dk    r|t          v rd| dfS |dk    rv|t
          v rddt
          |          dfS |t          v r<dd	l}| t          ||          u r%t          
                    d
| |          }d| dfS n|dk    rdd	l}| |j        u rdS dS )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_modulerb  r   r  r   s         r*   _raw_function_metar  W  s4   (3%		   vv g)/?"?"?	%%%%% 

	"	")))I*;I*FIIIII/))KKK743333599'I'' 	 )/////	 4
 '!!KKK4:%%226s    
$$columns	list[str]r   c                   |dk    rd}t          |          |o|d         }|s|dk    rdS t          | |          }|                                r|                    |           dS t	          |           \  }}|rM|rMt          |||          }||_        | j        }	|                    || d| |dk    r|	n| d|	            dS dS dS )	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  rQ  )r   r   r3  r`  r  r   r   r$   )
r   r   r   r   r   parsermodule
suggestionrP  fns
             r*   warn_on_inefficient_mapr  x  s4   " W2!#&&& %71:C 3"99t Hj11F!!## C 099
 	j 	*3
JGGK&1F#"BKK'2$A$AZ$A$A#)Z#7#7RR=M=M=M=M      		 	 	 	r)   r  )r   r   )r   r   r   r   r   r   r   r   )r   r   r   r  )r   r   r   r  r   r.   r   r   )Drh  
__future__r   r   r5  r   r   sysr_  bisectr   collectionsr   r   r   	itertoolsr   r	   pathlibr
   typingr   r   r   r   r   r   r   r]  r   collections.abcr   r   AbstractSetr   version_infor   typing_extensionsr   r.   r'   r   r/   ri   rj   r3   rh   r  r  r  r  r  r  r  rZ   r   r  compiler  r  r   r   r   r@  r   r  r  __all__r(   r)   r*   <module>r     s   T T T " " " " " "  



  				 



        # # # # # #                   ( ( ( ( ( ( ( (                        , + + + + + 0((((((222222
7""$$$$$$$//////# # # # # # # # 89	 9 9 9 9c:o.
 . . . .(
7C,7
3- 3- 3- 3- 3- 3- 3- 3-n ) : "	/22 9  > %	 	  (II 9.//5'9   %&&###  0  +L9:!+,-.*+   +L9:!+,z)*   +m_!+,z")   +m_+n-!+,#~%,"	 	  +m_+n-&-$./#T*+&<.%,"	 	[7>  7 7 7 7t !    #   BJNOO -..   :# # # #0r r r r r r r rjQ' Q' Q' Q' Q' Q' Q' Q'hJ J J J J J J JD   B* * * *Z 6
7r)   