J/PhZJzddlmZmZmZmZmZddlmZddlm Z ddl m Z ddl Z Gdde ZejedZd Zd ZGd d eZeZGd deZeZGddeZeZdZdZdZGddeZeZdS))typeserrorsirsigutilsir_utils) typeof_impl)find_region_inout_vars)build_definitionsNc(eZdZdZdZdZdZdZdS) WithContextzXA dummy object for use as contextmanager. This can be used as a contextmanager. FcdSNselfs W/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/core/withcontexts.py __enter__zWithContext.__enter__ cdSrrrtypvaltbs r__exit__zWithContext.__exit__rrct)aMutate the *blocks* to implement this contextmanager. Parameters ---------- func_ir : FunctionIR blocks : dict[ir.Block] blk_start, blk_end : int labels of the starting and ending block of the context-manager. body_block: sequence[int] A sequence of int's representing labels of the with-body dispatcher_factory : callable A callable that takes a `FunctionIR` and returns a `Dispatcher`. )NotImplementedError)rfunc_irblocks blk_startblk_end body_blocksdispatcher_factoryextras rmutate_with_bodyzWithContext.mutate_with_bodys "!rN)__name__ __module__ __qualname____doc__ is_callablerrr%rrrr r sRK      """""rr c*tj|Sr)rContextManager)rcs rtypeof_contextmanagerr.&s   $ $$rcf|ds|ddSdS)z.Get parent of the variable given its name $.rN) startswithsplit)names r_get_var_parentr5+s9 ??3  $zz#  ##$$rc|D]}||=dS)z-Remove keys in *to_clear* from *blocks*. Nr)rto_clearbs r _clear_blocksr94s& 1IIrceZdZdZdZdS)_ByPassContextTypez_A simple context-manager that tells the compiler to bypass the body of the with-block. c |J|j}d|j|D d|j|D fdtt D} t |||| t ||dS)Nc.i|]}t||Srr5.0ks r z7_ByPassContextType.mutate_with_body..Ds"GGG1##QGGGrc.i|]}t||Srr>r?s rrBz7_ByPassContextType.mutate_with_body..Es"FFFA/!$$aFFFrc.i|]}||Srr)r@rAinmapoutmaps rrBz7_ByPassContextType.mutate_with_body..Fs#IIIquQxIIIr)variable_lifetimelivemapfilterbool_bypass_with_contextr9) rrrr r!r"r#r$vlt forwardvarsrErFs @@rr%z#_ByPassContextType.mutate_with_body?s}}}'GG I0FGGGFFW1EFFFIIIIIF44H4HIII VYEEEfk*****rNr&r'r(r)r%rrrr;r;;s- + + + + +rr;ceZdZdZdZdS)_CallContextTypezqA simple context-manager that tells the compiler to lift the body of the with-block as another function. c |J|j}t|j||t|\} } fd|D} t | ||| | || t | t| d} || } t| ||| | }||<t|| S)NrrHcallfromreturntobody_block_idsc"i|] }|| Srrr@rArs rrBz5_CallContextType.mutate_with_body..`999q&)999rTr arg_names arg_countforce_non_generator) rGr rHset_mutate_with_block_calleederivetuplelen_mutate_with_block_callerr9)rrrr r!r"r#r$rLinputsoutputs lifted_blks lifted_ir dispatchernewblks ` rr%z!_CallContextType.mutate_with_bodySs}}}'0K{++ :999[999 !+y'"(' 3 3 3NNFmm&kk $ # (' 22 *  7FG#yfk***rNrNrrrrPrPOs-!!!!!rrPc.eZdZdZdZdZdZdZdZdS)_ObjModeContextTypea- Creates a contextmanager to be used inside jitted functions to enter *object-mode* for using interpreter features. The body of the with-context is lifted into a function that is compiled in *object-mode*. This transformation process is limited and cannot process all possible Python code. However, users can wrap complicated logic in another Python function, which will then be executed by the interpreter. Use this as a function that takes keyword arguments only. The argument names must correspond to the output variables from the with-block. Their respective values can be: 1. strings representing the expected types; i.e. ``"float32"``. 2. compile-time bound global or nonlocal variables referring to the expected type. The variables are read at compile time. When exiting the with-context, the output variables are converted to the expected nopython types according to the annotation. This process is the same as passing Python objects into arguments of a nopython function. Example:: import numpy as np from numba import njit, objmode, types def bar(x): # This code is executed by the interpreter. return np.asarray(list(reversed(x.tolist()))) # Output type as global variable out_ty = types.intp[:] @njit def foo(): x = np.arange(5) y = np.zeros_like(x) with objmode(y='intp[:]', z=out_ty): # annotate return type # this region is executed by object-mode. y += bar(x) z = y return y, z .. note:: Known limitations: - with-block cannot use incoming list objects. - with-block cannot use incoming function objects. - with-block cannot ``yield``, ``break``, ``return`` or ``raise`` such that the execution will leave the with-block immediately. - with-block cannot contain `with` statements. - random number generator states do not synchronize; i.e. nopython-mode and object-mode uses different RNG states. .. note:: When used outside of no-python mode, the context-manager has no effect. .. warning:: This feature is experimental. The supported features may change with or without notice. Tc|rtjdi}d}|D]\} } t| tjr7t| jtrtj | j|| <Wt| tj r< || j } n'#t$r|| d| j d|YnwxYw| || <t| tj r= || j } n'#t$r|| d| j d|YnwxYw| || <t| tjrm| jdkrb || j} t#| | j} | || <`#tjt(f$r|| d|YwxYw|| d ||D]\} } || | ||S) a> Legalize arguments to the context-manager Parameters ---------- func_ir: FunctionIR args: tuple Positional arguments to the with-context call as IR nodes. kwargs: dict Keyword arguments to the with-context call as IR nodes. loc: numba.core.ir.Loc Source location of the with-context call. func_globals: dict The globals dictionary of the calling function. func_closures: dict The resolved closure variables of the calling function. z8objectmode context doesn't take any positional argumentsc:tjd|d||)Nz Error handling objmode argument z. loc)r CompilerErrorvarnamemsgrns r report_errorz8_ObjModeContextType._legalize_args..report_errors2&IwIICII rzFreevar z is not defined.rpzGlobal getattrz+Getattr cannot be resolved at compile-time.z}The value must be a compile-time constant either as a non-local variable or a getattr expression that refers to a Numba type.)rroitems isinstancerConstvaluestrr_parse_signature_stringFreeVarr4KeyErrorGlobalExpropinfer_constantrtattrConstantInferenceErrorAttributeError_legalize_arg_type)rrargskwargsrn func_globals func_closurestypeannsrsrAvbase_objrr4s r_legalize_argsz"_ObjModeContextType._legalize_argss&  &J     LLNN* * DAq!RX&&) :ags+C+C) &>qwGG Arz**' %af-AA L !AqvAAA   Ary)) $QV,AA L !@af@@@   Arw'' ADI,=,= &&55ag>>H!(AF33C#&HQKK5~F L !I 3 ")) 4 4ID#  # #D#s 3 3 3 3s6" B00!CC8 D!D*)D*/F$F87F8ct|ddr5dd|d|ddg}tjd|| d S) aLegalize the argument type Parameters ---------- name: str argument name. typ: numba.core.types.Type argument type. loc: numba.core.ir.Loc source location for error reporting. reflectedFzObjmode context failed.z Argument z% is declared as an unsupported type: r1z"Reflected types are not supported. rmN)rtrrojoin)rr4rrnmsgbufs rrz&_ObjModeContextType._legalize_arg_type sy 3 U + + B)/D//(+///5 F &sxx'7'7SAAA A B Brc  |jjjj}|jjj} |jjj} | Qi} t || D]=\} } | j}|| | <#t$r}t|dkrYd}~6d}~wwxYwni} |r|dnd}|r|dni}| ||||j | |  |j }t|j||t|\}}d}t!t#||}t t|z }|r)d}t%j||t*j d <t|t z }|r?d }t/|}t%j|||d t+j fd |D}fd |D}t3|||||||t7|t9|d}||d|}t;|||||}||<t=||S)Nz Cell is emptyrrr)rrrrnrrrRc:|dddS)Nr1r)r3)xs r strip_var_verz;_ObjModeContextType.mutate_with_body..strip_var_verGs773??1% %rzkInvalid type annotation on non-outgoing variables: {}.Suggestion: remove annotation of the listed variablesz$cpzrMissing type annotation on outgoing variable(s): {0} Example code: with objmode({1}='') rc g|] }| Srr)r@rrs r z8_ObjModeContextType.mutate_with_body..hsAAAahqkAAArc"i|] }|| SrrrWs rrBz8_ObjModeContextType.mutate_with_body..jrXrTrY) objectmode output_types)func_idfunc__code__ co_freevars __closure__ __globals__zip cell_contents ValueErrorryrrnrGr rHr]listmapr TypingErrorformatrint32sortedTupler^r_r`rarbr9)!rrrr r!r"r#r$ cellnamesclosuresrrcellnameclosurecellvalerrrLrcrdr stripped_outsextra_annotatedrr not_annotated stable_annouttuprerfrgrhrs! ` @rr%z$_ObjModeContextType.mutate_with_bodys$O(1= ?'3+7  M%(H%=%= 6 6!'6%3G /6M(++ "1vv0010000 6M %-uV}}2$)1xr&&w,0.4+1)+<+@4@5B '))'0K{++  & & &S8899 h--#m*<*<<  BH $SZZ%@%@AA A +M**S]]:  L0   ..J$SZZ JqM%J%JKK KAAAA=AAABB9999[999 !+y'"(' 3 3 3NNFmm&kk $ # (' d5;=== +  7FG#yfk***sA"" B ,BB c|Srrrrrs r__call__z_ObjModeContextType.__call__s rN) r&r'r(r)r*rrr%rrrrrjrjzsm::vKOOObBBB*```Drrjc ||}|j}|j}tj||}|D]U\}} |tj|||| |V|tj|||||<dS)zGiven the starting and ending block of the with-context, replaces the head block with a new block that jumps to the end. *blocks* is modified inplace. scopern)rxtargetrn)rrnN) rrnrBlockruappendAssign get_exactJump) rr r!rMsblkrrnrhrArs rrKrKs ) D JE (C XEs + + +F!!##**1 bieooa&8&8',q'9'9$'))) * * * * MM"'c222333F9rc||}|j}|j}tj||} t j| ||||| S)akMake a new block that calls into the lifeted with-context. Parameters ---------- dispatcher : Dispatcher blocks : dict[ir.Block] blk_start, blk_end : int labels of the starting and ending block of the context-manager. inputs: sequence[str] Input variable names outputs: sequence[str] Output variable names r)newblockcallee label_nextrcrd)rrnrrrfill_block_with_call) rgrr r!rcrdrrrnrs rrbrbs` ) D JE (Cxe---H !      Orc2|stjdt|}||}|j}|j}t jtj||||||<t j tj|||||<dS)aFMutate *blocks* for the callee of a with-context. Parameters ---------- blocks : dict[ir.Block] blk_start, blk_end : int labels of the starting and ending block of the context-manager. inputs: sequence[str] Input variable names outputs: sequence[str] Output variable names zNo blocks in with-context blockr)blockrcr)rrdN) rNumbaValueErrorminrrnrfill_callee_prologuerrfill_callee_epilogue) rr r!rcrdhead_blktemp_blkrrns rr^r^s H$%FGGG6{{HhH NE ,C 5hU,,,   F9 3hU,,,F7OOOrc,eZdZdZ dZdZdZdZdS)_ParallelChunksizeTc rtj|d||J|d}t|dksJ|d} ||j} ||j} t | t jrt j| | j | } g} g} | d| }| t j t j dt| || t j|d| }| d | }| t j ||| | d | }| d | }| t j | || t j||gd | }| t j ||| t j||gd | }| t j ||| ||jdd | z||jd gz||_| ||jz||_t'||_tj|d|dS)NzBefore with changes)rrrrz$ngvarnumbaset_parallel_chunksizez$spcz$save_pcz$cs_varrzAfter with changes)rdprint_func_irrarrnrvrArgVarr4redefinerrr}rr~rtcallbodyr _definitions)rrrr r!r"r#r$rargrrn set_state restore_stategvarspcattrspcvar orig_pc_varcs_varspc_callrestore_spc_calls rr%z#_ParallelChunksize.mutate_with_bodysv)>vNNNN   V}4yyA~~~~1gy!'Y# c26 " " /&#..C  ~~h,,29WeS#A#A4MMNNN'//$(@#FF,,7FC88999nnZ55  3//3445557<<"c::8[#>>???7<< r3GGRY'7cJJKKK"("3"82">"+#,#))#4#9"#=">#?y -vg/CCw088)=fMMMMMMrct|dks|st|dtstd|d|_|S)zvAct like a function and enforce the contract that setting the chunksize takes only one integer input. rrz8parallel_chunksize takes only a single integer argument.)rarvintr chunksizers rrz_ParallelChunksize.__call__sR t99>>V>:d1gs+C+C>899 9a rchtj|_tj|jdSr)rget_parallel_chunksizeorig_chunksizerrrs rrz_ParallelChunksize.__enter__s,#:<< $T^44444rc8tj|jdSr)rrrrs rrz_ParallelChunksize.__exit__s $T%899999rN)r&r'r(r*r%rrrrrrrrs^K %N%N%NN   555:::::rr) numba.corerrrrrnumba.core.typing.typeofrnumba.core.transformsr numba.core.ir_utilsr robjectr registerr.r5r9r;bypass_contextrP call_contextrjobjmode_contextrKrbr^rparallel_chunksizerrrrs<<<<<<<<<<<<<<000000888888111111 """""&"""<k""%%#"%$$$++++++++"$#%%%%%%%{%%%P !! HHHHH+HHHV&%''$<