o
    i                     @  s   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 ddlmZ ddlmZmZ erddl m!Z!m"Z"m#Z# ddl m$Z% ddlm&Z& ddlm'Z' ddlm(Z( G dd deZ)ed Z*de+d< e,e)B Z-de+d< ej.dkZ/de+d< e/oej.dkZ0de+d< e0oej.dkZ1de+d< edZ2d e+d!< G d"d# d#Z3e4d$Z5d%e+d&< e4d'Z6d%e+d(< e4d)Z7d%e+d*< d+d,d-d.d/d0d1d2d3Z8d4e+d5< d6d7d8d9Z9d4e+d:< e4e9d;hB Z:d%e+d<< i d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcddZ;d4e+de< dfdghgg e3j<gg e6gg e7gdhdfdghgg e3j<gg dihgg e5gdhdfhgg e3j<gg djhgg dkhgdhdfhgdghge3j<gg dlhgg dmhgdndodfhgdghgdphge3j<gdldqhgdlhgdmhgdndogZ=dre+ds< dtdu e=D Z=dvdwdxdydzd{d|d}Z>d4e+d~< e?dZ@de+d< e?dZAde+d< e?dZBde+d< dddZCdddZDG dd dZEG dd dZFG dd dZGdddZHdddZIddgZJdS )zNUtilities related to user defined functions (such as those passed to `apply`).    )annotationsN)bisect_left)defaultdict)get_instructions)	signature)countzip_longest)Path)TYPE_CHECKINGAnyClassVarFinalLiteral
NamedTuple)LRUCache)
no_default	re_escape)CallableIteratorMutableMapping)Set)Instruction)	TypeAlias)	NoDefaultc                   @  s:   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'   r'   I/home/app/Keep/.python/lib/python3.10/site-packages/polars/_utils/udfs.pyr   &   s   
 r   )exprframeseriesr   	MapTarget
StackEntry)      r   
_MIN_PY311)r.      
_MIN_PY312)r.      
_MIN_PY314    z@MutableMapping[tuple[Callable[[Any], Any], str], BytecodeParser]_BYTECODE_PARSER_CACHE_c                   @  s  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B 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B ee	B eeB e
B ZeeeB eeB eB eB 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)ZPOP_JUMP_FORWARD_IF_FALSEZPOP_JUMP_FORWARD_IF_TRUEJUMP_IF_FALSE_OR_POPJUMP_IF_TRUE_OR_POP)POP_JUMP_IF_FALSEPOP_JUMP_IF_TRUErR   rS   CONTROL_FLOW)
LOAD_CONST
LOAD_DEREF	LOAD_FASTLOAD_GLOBALLOAD_METHOD	LOAD_ATTRrY   rW   )ZLOAD_FAST_BORROWLOAD_SMALL_INTSIMPLIFY_SPECIALIZEDPOLARS_EXPRESSION   zClassVar[dict[str, int]]	SYNTHETIC~)UNARY_NEGATIVEUNARY_POSITIVE	UNARY_NOTUNARY>   BINARY_SUBSCR
COMPARE_OPCONTAINS_OPIS_OP	BINARY_OPN)r#   r$   r%   rN   r&   	frozensetr0   rO   r2   rV   ZLOAD_VALUESr\   LOADr^   ra   rf   setPARSEABLE_OPSMATCHABLE_OPSvaluesUNARY_VALUESr'   r'   r'   r(   r7   :   sp   
 		
r7   )acosacoshasinasinhatanatanhcbrtceilcoscoshdegreesexpfloorloglog10log1ppowradianssinsinhsqrttantanhzFinal[frozenset[str]]_MATH_FUNCTIONS)npnumpy_NUMPY_MODULE_ALIASES)arccosarccosharcsinarcsinharctanarctanhry   rz   r{   r|   r}   r~   r   r   r   r   r   signr   r   r   r   r   _NUMPY_FUNCTIONSz	dt.date()zdt.day()z	dt.hour()zdt.microsecond()zdt.minute()z
dt.month()zdt.second()z	dt.year())datedayhourmicrosecondminutemonthsecondyearzFinal[dict[str, str]]_PYTHON_ATTRS_MAPZFloat64ZInt64String)floatr   r   _PYTHON_CASTS_MAPabs_PYTHON_BUILTINSendswithstr.ends_withlowerzstr.to_lowercaselstripzstr.strip_chars_startremoveprefixzstr.strip_prefixremovesuffixzstr.strip_suffixreplacestr.replacerstripzstr.strip_chars_end
startswithstr.starts_withstripzstr.strip_charstitlezstr.to_titlecaseupperzstr.to_uppercasezfillz	str.zfillr   zdt.dater   zdt.dayr   zdt.hour
isoweekdayz
dt.weekdayr   zdt.microsecondzdt.monthz	dt.secondzdt.strftimezdt.timezdt.year)r   r   strftimetimer   _PYTHON_METHODS_MAPrY   rW   )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_FUNCTIONSc                 C  s2   g | ]}t tjgg fD ]
}i |d |iqqS )argument_1_unary_opname)rn   r7   rf   ).0kindZunaryr'   r'   r(   
<listcomp>  s    r   r   r   r   r   r   r   str.json_decode)z	math.acosz
math.acoshz	math.asinz
math.asinhz	math.atanz
math.atanhz
json.loads_MODULE_FUNC_TO_EXPR_NAMEz,pl\.col\("([^"]*)"\) & pl\.col\("\1"\)\.(.+)_RE_IMPLICIT_BOOLz^(s|srs\d?|series)\._RE_SERIES_NAMESz^bool\((.+)\)$_RE_STRIP_BOOLreturndict[str, Any]c                  C  s|   t tjj} t }d}z/|r&t|}|t| r#|j}|d7 }nn|s|du r0i }W ~|S i |j	|j
}W ~|S ~w )z7Get all local and global variables from caller's frame.r   r`   N)r	   __file__parentinspectcurrentframegetfiler   r   f_backf_locals	f_globals)Zpkg_dirr*   nfname	variablesr'   r'   r(   _get_all_caller_variables,  s&   

r   colr   
expression
map_targetc                 C  s   d|  d}|dkr|S |dkrNt |r|ddd S ||d}d	D ]}td
| d
|s5|  S q%t }	 dt| }td
| d
|sM|S q:d|}t|)z@The name of the object against which the 'map' is being invoked.pl.col("")r)   r+   .r`   r    )ssrsr+   z\bTr   zTODO: map_target = )	r   matchsplitr   researchr   nextNotImplementedError)r   r   r   Zcol_exprZsearch_exprnamer   msgr'   r'   r(   _get_target_nameI  s&   

r   c                   @  s   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
< d7ddZ
d8ddZed9ddZd:ddZed;d d!Zd<d#d$Zd=d%d&Zed>d'd(Zed?d)d*Zed@d+d,Zed?d-d.ZdAd0d1Zddd2dBd5d6ZdS )C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_expressionfunctionCallable[[Any], Any]r   r,   r   Nonec                 C  sV   zt |}W n ty   tg }Y nw || _|| _| || _t|| j|d| _	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_instructionsr'   r'   r(   __init__j  s   zBytecodeParser.__init__r)   r   c                 C  s&   t |rt jd|d}t |s|S )zIDrop extraneous/implied bool (eg: `pl.col("d") & pl.col("d").dt.date()`).zpl.col("\1").\2)replstring)r   r   sub)r  r)   r'   r'   r(   _omit_implicit_bool  s   

z"BytecodeParser._omit_implicit_boolc                 C  sH   zt | }W n
 ty   Y dS w t|j }dkr"tt| S dS )z&Return single function parameter name.Nr`   )r   
ValueErrorlen
parametersr   r   keys)r   sigr  r'   r'   r(   r     s   zBytecodeParser._get_param_nameexpression_blocksdict[int, str]logical_instructionslist[Instruction]list[tuple[int, str]]c                 C  s   |r^t dd |D dkrPt| }d}|D ]8}|t||jd  }|t||jd  }|dkr7||d ksO|||fvrOd||  ||< ||  d7  < |}q|D ]}tj|j ||j< qRt	|
 S )zBInject nesting boundaries into expression blocks (as parentheses).c                 S  s   h | ]}|j qS r'   opnamer   instr'   r'   r(   	<setcomp>  s    z1BytecodeParser._inject_nesting.<locals>.<setcomp>r`   r   ())r
  listr  r   offsetargvalr7   rV   r  sorteditems)r  r  r  Zblock_offsetsZprev_endr  startendr'   r'   r(   _inject_nesting  s    zBytecodeParser._inject_nestingc                 C     | j S )z8The map target, eg: one of 'expr', 'frame', or 'series'.)r   r  r'   r'   r(   r        zBytecodeParser.map_targetboolc                 C  sV   | j du r(| jduo&t| jdko&tdd | jD o&td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                 s  s    | ]	}|j tjv V  qd S N)r  r7   ro   r  r'   r'   r(   	<genexpr>  s
    

z5BytecodeParser.can_attempt_rewrite.<locals>.<genexpr>c                 s  s    | ]
}|j d krdV  qdS )RETURN_VALUEr`   Nr  r  r'   r'   r(   r)    s    
r`   )r   r   r
  r  allsumr  r$  r'   r'   r(   can_attempt_rewrite  s   

z"BytecodeParser.can_attempt_rewritec                 C  s   t  | j dS )z%Print disassembled function bytecode.N)disr   r$  r'   r'   r(   r.    s   zBytecodeParser.disc                 C  r#  )zThe function being parsed.)r   r$  r'   r'   r(   r     r%  zBytecodeParser.functionc                 C  s   t | jjS )zDThe original bytecode instructions from the function we are parsing.)r  r  _original_instructionsr$  r'   r'   r(   r    s   z$BytecodeParser.original_instructionsc                 C  r#  )z0The parameter name of the function being parsed.)r   r$  r'   r'   r(   
param_name  r%  zBytecodeParser.param_namec                 C  
   t | jS )zEThe rewritten bytecode instructions from the function we are parsing.)r  r  r$  r'   r'   r(   rewritten_instructions  s   
z%BytecodeParser.rewritten_instructionsr   c                   s  j tur-j dur-j \}} |kr+tdt| ddt  d|} |f_ |S d_jdu r:d_ dS tt}g d}t	j
D ]\}}|jtjv r_j
|d  j}| qG|| | qGz fdd	| D }W n ty   d_ Y dS w d
dd |D }	d|	vrd_ dS |	}	jdkrj }
du rt |	j}
|	d  d|
}	 |	f_ |	S )zDTranslate postfix bytecode instructions to polars expression/string.Nz
pl\.col\("z"\)r   r   r   r`   c              	     s>   i | ]\}}|t |jjjd j jttdqS ))r   r   r   r   )r   r0  depth)InstructionTranslatorr   r   r   to_expressionr   r   r&  )r   r  opsr   r  r  r'   r(   
<dictcomp>  s    
z0BytecodeParser.to_expression.<locals>.<dictcomp> c                 s  s    | ]\}}|V  qd S r(  r'   )r   _offsetr)   r'   r'   r(   r)        z/BytecodeParser.to_expression.<locals>.<genexpr>pl.col(r+   )r   r   r   r  r   r   r   r   r  	enumerater  r  r7   rV   r  appendr"  r  r   joinr  r   r   r   )r  r   Zcol_namer)   Zcontrol_flow_blocksZjump_offsetidxr  Zexpression_stringsZpolars_exprtarget_namer'   r7  r(   r5    sX   





zBytecodeParser.to_expressionsuggestion_overrideudf_overriderC  rD  c             	   C  s  ddl m}m} ddlm} |p| |}|dur| j }du r't||| j}|p.| j	j
p.d}	|	dkr:d| j d}	d	|v r@d
nd}
| jdkrIdnd\}}| rad| d|	 dd| d|
 fnd| d|	 dd| d|
 f\}}tjd| 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)   )ZexpressionsExpr)r+   Z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  Zpolars.exceptionsrG  r5  r   r   r   r   r#   r   warningswarn)r  r   rC  rD  rE  rF  rG  Zsuggested_expressionrA  	func_nameZaddendumZapitypeclsnamebeforeafterr'   r'   r(   rM  /  sL   



zBytecodeParser.warn)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   rC  r!   rD  r!   r   r   )r#   r$   r%   __doc__r   r&   r   r   r   r   r  r  staticmethodr   r"  propertyr   r-  r.  r   r  r0  r2  r5  rM  r'   r'   r'   r(   r   b  s6   
 





Hr   c                   @  sF   e Zd ZdZd ddZd!ddZed"ddZd#ddZd$ddZ	dS )%r4  z>Translates Instruction bytecode to a polars expression string.r   r  r   r   r   r   r   r,   r   r   c                 C  s   |  ||| _|| _|| _d S r(  )_to_intermediate_stack_stackr   r   )r  r   r   r   r   r'   r'   r(   r  n  s   
zInstructionTranslator.__init__r   r   r0  r3  r   c                 C  s   |  | j|||S )z7Convert intermediate stack to polars expression string.)_exprrV  )r  r   r0  r3  r'   r'   r(   r5  y  s   z#InstructionTranslator.to_expressionr  r   c                 C  s   | j  }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 r3tj| S |dkr9dS d	| d
| }t|)z@Convert bytecode instruction to suitable intermediate op string.rj   is notisri   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` expression and the following instruction object:
)r  r7   rV   argreprr  rf   AssertionError)r  r  r   r'   r'   r(   op}  s"   


zInstructionTranslator.opvaluer-   c                 C  st  t |tr-td|j}| |j|||d }|jdkr|tj	vr|
dr9|dr.dnd}| d| | S |d tj	v r\|dd	 
dr\|drPdnd}d
| d| | S |jtv rh|tv rhd}n|jdkr{td| |tv r{d}nd}| | d
| dS | | S | |j|||d }	|dv r|jdkr|dkrdnd}
| d|
 dS |dv r|dkrdnd}
d|v r|
 d
| d|	 dS |
 | d|	 dS |dkr| jst | _t | j|d	tsd}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r8d"| d#S |S )$z?Take stack entry value and convert to polars expression string.z\1r`   r<  r  r   ()r   r   Nr  z).znp.r   math.)rY  rX  r   rY  not_z.is_znull())r[  rZ  r[  rb   r9  z.is_in(z))r\  zrequire dict mappingr:   z * 2**z).cast(pl.Int64)r;   z / 2**r   r   )
isinstancer   r   r  r   rW  r   r   r7   rr   r   r   r"   r   r   r   getr   r    r   r   dictr   )r  r`  r   r0  r3  r_  e1callpfxe2rc  r   r)   r'   r'   r(   rW    sb   


 




zInstructionTranslator._exprc                 C  s   |dv rRg }|D ]E}| |jtjv r|jn6|jtjv s$tj|jdkr6t| 	|d|
 dt|dddnt| 	|d|
d|
dt|ddd q|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.)r>  r  r7   rm   r]  rf   ra   re  r   r_  popgetattrr   )r  r   r   stackr  r   r'   r'   r(   rU    s4   

z,InstructionTranslator._to_intermediate_stackN)
r   r  r   r   r   r   r   r,   r   r   )r   r   r0  r   r3  r   r   r   )r  r   r   r   )
r`  r-   r   r   r0  r   r3  r   r   r   )r   r  r   r,   r   r-   )
r#   r$   r%   rR  r  r5  rS  r_  rW  rU  r'   r'   r'   r(   r4  k  s    


Cr4  c                   @  s   e Zd ZdZeg dZd:ddZd;ddZd<ddZd=ddZ	ddd>d!d"Z
d?d#d$Zd@d&d'Zd@d(d)Zd@d*d+Zd@d,d-ZedAd.d/ZedBd1d2ZdCd7d8Zd9S )Dr   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.
    )	COPYZCOPY_FREE_VARSZ	NOT_TAKENPOP_TOPZPRECALLZ	PUSH_NULLRESUMEr*  ZTO_BOOLr   Iterator[Instruction]r   r   r   r   r   r   c                 C  st   || _ || _t|| _g }| | jD ]}|j| jvr1|jtjvr'g | _	 d S | 
|}|| q| || _	d S r(  )r   r   r  r/  _unpack_superinstructionsr  _ignored_opsr7   rp   r  _update_instructionr>  _rewrite)r  r   r   r   Znormalised_instructionsr  Zupgraded_instr'   r'   r(   r    s   


zRewrittenInstructions.__init__r   c                 C  r1  r(  )r
  r  r$  r'   r'   r(   __len__,     
zRewrittenInstructions.__len__c                 C  r1  r(  )r   r  r$  r'   r'   r(   __iter__/  ry  zRewrittenInstructions.__iter__itemr   r   c                 C  s
   | j | S r(  )r  )r  r{  r'   r'   r(   __getitem__2  ry  z!RewrittenInstructions.__getitem__F)is_attrr@  opnameslist[AbstractSet[str]]argvals5list[AbstractSet[Any] | dict[Any, Any] | None] | Noner}  r&  r  c          	      C  s   t ||pg }}|| }|r$| j||d   }r$|d jtjv r$g S | j|| }t ||kr@td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                 s  s2    | ]\}}}|j |v o|d u p|j|v V  qd S r(  )r  r  )r   r  Zmatch_opnamesZmatch_argvalr'   r'   r(   r)  U  s    

z1RewrittenInstructions._matches.<locals>.<genexpr>)r
  _instructionsr  r7   rO   r+  r   )	r  r@  r~  r  r}  Zn_required_opsZ
idx_offsetZtrailing_instr   r'   r'   r(   _matches5  s    zRewrittenInstructions._matchesc                   s   || _ g d  t| j k rC| j   d}|jtjvs1t fdd| j| j| j| j	fD s6
|  p:d7   t| j k s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  s    | ]
}|  V  qd S r(  r'   )r   Zmap_rewriter@  	incrementupdated_instructionsr'   r(   r)  l  s
    
z1RewrittenInstructions._rewrite.<locals>.<genexpr>)r  r
  r  r7   rm   any_rewrite_functions_rewrite_methods_rewrite_builtins_rewrite_attrsr>  )r  r   r  r'   r  r(   rw  _  s    

zRewrittenInstructions._rewriter  c                 C  s^   | j |dhdhgdtgdd }r+|d }t|j }|jd||d}||d	 |g t|S )
zDReplace python attribute lookup with synthetic POLARS_EXPRESSION op.rY   r\   NT)r~  r  r}  r`   r_   r  r  r]  r   )r  r   r  _replaceextendr
  )r  r@  r  matching_instructionsr  	expr_namepxr'   r'   r(   r  z  s   


z$RewrittenInstructions._rewrite_attrsc           
      C  s   | j |dhddhtjgtgd }rC|dd \}}|j }tv r+t| }d| d}|jd	|||jd
}|j|jd}	||	|f t	|S )zEReplace builtin function calls with a synthetic POLARS_EXPRESSION op.rZ   rY   rW   r~  r  Nr'  cast(pl.r  r_   r  r  r]  r  r  )
r  r7   rO   r   r  r   r  r  r  r
  )
r  r@  r  r  inst1inst2r  Zdtyper  operandr'   r'   r(   r    s$   
z'RewrittenInstructions._rewrite_builtinsc                   sd  dD ],}t D ]&}|r|dds  dS |r,ddhg|d |d |d	 tjnddhg|d
 |d |d |d |d	 tj}|d }| j|||rXg |d ng |d |d |d d }r.t|d }||d|  \}	}
}|r| jst | _|	j }| jvrq| j| j	 t
 fdd|D sqt  d| |}nB|	jdkrd}n:|	jdkr||d  j}d| d}| |	j|d j|st|    S n|	jdkrtd|
j |
j}n|
j}|r|
n|}|	jd|||jd}|rdn|	jpd|_|j|	jd}||d r!||d|  |fn||f t|    S qqdS )z=Replace function calls with a synthetic POLARS_EXPRESSION op.)FTr   Tr   rZ   rX   r   r   r   r   r   r   r   r   r  r.   c                 3  s    | ]} |v V  qd S r(  r'   )r   mr   r'   r(   r)    r;  z;RewrittenInstructions._rewrite_functions.<locals>.<genexpr>r   r   r   r   zstr.to_datetime(format="r   r   rb  r_   r  Nr  )r   re  r7   rO   r  r
  r   r   r  r$   r  r   _is_stdlib_datetimer  r  rk  r  )r  r@  r  Zcheck_globalsZfunction_kindr~  Zmodule_aliasesr  attribute_countr  r  Zinst3r  fmtZ	swap_instr  r  r'   r  r(   r    s   


	





	^z(RewrittenInstructions._rewrite_functionsc              	   C  s$  t rtjndh}| j||dhtjgtgdp!| j||tjgtgd }r|d }t|j }|d jdkrw|d j}t|t	ro|dv rod|v rHdnd	\}}	d

dd |D }
d|v r\dnd}d| | d|
 d|	 | d	}n|d|d7 }|jd||d}|| t|S | j||dhdhdhtjgtgdp| j||dhdhtjgtgd }r|d }t|j }dd |dt|d  D }|dkrt|dkr|\}}}|d|d|d| d7 }n|\}}d|d|d}n|dd
dd |D  d7 }|jd||d}|| t|S )z@Replace python method calls with synthetic POLARS_EXPRESSION op.r[   rW   r  r   r`   )r   r   starts)rA   r   )r   $r>   c                 s      | ]}t |V  qd S r(  )r   r   vr'   r'   r(   r)  (  r;  z9RewrittenInstructions._rewrite_methods.<locals>.<genexpr>'"zstr.contains(rr  r  r_   r  c                 S  s   g | ]}|j qS r'   )r  )r   ir'   r'   r(   r   I  s    z:RewrittenInstructions._rewrite_methods.<locals>.<listcomp>r   r.   ,z,n=z,literal=True)zstr.replace_all(c                 s  r  r(  )reprr  r'   r'   r(   r)  U  r;  )r2   r7   r\   r  rO   r   r  r  rd  tupler?  r  r>  r
  )r  r@  r  r[   r  r  r)   Zparam_valuer  Zendsrxqr  Zparam_valuesoldnewr   r'   r'   r(   r  
  sp   

"
+

 
z&RewrittenInstructions._rewrite_methodsc                 c  sJ    | D ]}|j dv rdD ]}|jd|j| |j| dV  qq|V  qdS )z<Expand known 'superinstructions' into their component parts.)ZLOAD_FAST_LOAD_FASTZ!LOAD_FAST_BORROW_LOAD_FAST_BORROW)r   r`   rY   r  N)r  r  r  )r   r  r@  r'   r'   r(   rt  \  s   

z/RewrittenInstructions._unpack_superinstructionsr  c                 C  s   t s| jtjv r| jtj| j dd} | S trL| j }tjv r<dtj| j i}|dkr2t| j|d< | jdi |} | S |dkrL| j	dkrL| jddd	} | S )zFUpdate/modify specific instructions to simplify multi-version parsing.rk   )r]  r  r  r]   r]  z[]rg   r   )r  r]  Nr'   )
r0   r  r7   rN   r  r4   r^   r   r  r]  )r  r  Zupdated_paramsr'   r'   r(   rv  o  s    
z)RewrittenInstructions._update_instructionr   r   r   r  c                 C  sB   | j st | _ | j }|dko||tju p |dko ||tu S )Nr   r`   )r   r   re  r   )r  r   r   r  varsr'   r'   r(   r    s   z)RewrittenInstructions._is_stdlib_datetimeN)r   rs  r   r   r   r   r   r   )r   r   )r   rs  )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   rs  )r  r   r   r   )r   r   r   r   r  r   r   r&  )r#   r$   r%   rR  rl   ru  r  rx  rz  r|  r  rw  r  r  r  r  rS  rt  rv  r  r'   r'   r'   r(   r     s*    	



	
*



eRr   r   r   tuple[str, str]c                 C  s   z	| j j}| j}W n
 ty   Y dS w |dkr#|tv r#d| dfS |dkre|tv r5ddt|  dfS |tv rVdd	l}| t||u rTt	
d
| |}d| dfS dS |dkredd	l}| |ju redS dS )zIIdentify translatable calls that aren't wrapped inside a lambda/function.)r   r   r   r   ra  builtinsr  r  r   Nrb  r   r   )r   zstr.json_decode())	__class__r$   r#   AttributeErrorr   r   r   r   rn  r   re  r   r   )r   Zfunc_modulerN  r   r  r   r'   r'   r(   _raw_function_meta  s0   


r  columns	list[str]r   c                 C  s   |dkr
d}t ||o|d }|s|dkrdS t| |f } }du r.t| |}|t|< | r9|| dS t| \}}|ri|rkt|||}	|	|_| j	}
|j||	 d| |dkr^|
n| d|
 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 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  rB  )
r   r6   re  r   r-  rM  r  r   r   r#   )r   r  r   r   r   keyparsermoduleZ
suggestionrA  fnr'   r'   r(   warn_on_inefficient_map  s,   

r  )r   r   )r   r   r   r   r   r   r   r   )r   r   r   r  )r   r   r  r  r   r,   r   r   )KrR  
__future__r   r   r.  r   r   sysrL  bisectr   collectionsr   r   r   	itertoolsr   r   pathlibr	   typingr
   r   r   r   r   r   Zpolars._utils.cacher   rK  r   r   collections.abcr   r   r   r   AbstractSetr   r   r   r   r,   r&   r   r-   version_infor0   r2   r4   r6   r7   rl   r   r   r   r   r   r   r   r\   r   r   compiler   r   r   r   r   r   r4  r   r  r  __all__r'   r'   r'   r(   <module>   sJ    	
=	
:	

      

!/