ó \ K]c@sWddlZddlZddlZddlZddlmZmZddlmZddl m Z m Z ddl m Z mZmZmZmZmZddlmZmZddlmZmZmZmZdd lmZd „Zied 6Z ied „Z!d „Z"d„Z#d„Z$d„Z%de&fd„ƒYZ'd„Z(d„Z)dS(iÿÿÿÿN(ttypestconfigi(t typeof_impl(tinfert infer_getattr(t lower_builtint lower_getattrtlower_getattr_generict lower_setattrtlower_setattr_generict lower_cast(tmodelstregister_default(tboxtunboxtreflectt NativeValue(t_import_cython_functioncs”ddlm‰m‰m‰tˆƒ rHtˆtƒ rHtdƒ‚ny ˆj‰Wnt k rttˆƒ‰nX‡‡‡‡‡fd†}|S(sØ Decorate a function as implementing typing for the callable *func*. *func* can be a callable object (probably a global) or a string denoting a built-in operation (such 'getitem' or '__array_wrap__') i(tCallableTemplateRt infer_globals%`func` should be a function or stringcs‡fd†}dˆf}ˆf}tdˆd|ƒ}t|||ƒ}ˆ|ƒtˆƒr{ˆˆtj|ƒƒndS(Ncs ˆ|jƒS(N(tcontext(tself(t typing_func(s.lib/python2.7/site-packages/numba/extending.pytgeneric"ss%s_CallableTemplatetkeyR(tdictttypetcallableRtFunction(RRtnametbasest class_dictttemplate(Rtfunct func_nameRR(Rs.lib/python2.7/site-packages/numba/extending.pytdecorate!s    ( ttyping.templatesRRRRt isinstancetstrt TypeErrort__name__tAttributeError(R!R#((RR!R"RRs.lib/python2.7/site-packages/numba/extending.pyt type_callables   tno_cpython_wrappercsNddlm‰m‰tjƒ‰ˆj|ƒ‡‡‡‡‡fd†}|S(s· A decorator marking the decorated function as typing and implementing *func* in nopython mode. The decorated function will have the same formal parameters as *func* and be passed the Numba types of those parameters. It should return a function implementing *func* for the given types. Here is an example implementing len() for tuple types:: @overload(len) def tuple_len(seq): if isinstance(seq, types.BaseTuple): n = len(seq) def len_impl(seq): return n return len_impl Compiler options can be passed as an dictionary using the **jit_options** argument. Overloading strictness (that the typing and implementing signatures match) is enforced by the **strict** keyword argument, it is recommended that this is set to True (default). To handle a function that accepts imprecise types, an overload definition can return 2-tuple of ``(signature, impl_function)``, where the ``signature`` is a ``typing.Signature`` specifying the precise signature to be used; and ``impl_function`` is the same implementation function as in the simple case. i(tmake_overload_templateRcsHˆˆ|ˆˆƒ}t|ƒtˆƒrDˆˆtj|ƒƒn|S(N(RRRR(t overload_funcR (R!RR,toptststrict(s.lib/python2.7/site-packages/numba/extending.pyR#[s   (R$R,Rt_overload_default_jit_optionstcopytupdate(R!t jit_optionsR/R#((R!RR,R.R/s.lib/python2.7/site-packages/numba/extending.pytoverload5s   cs'‡fd†}ˆr|S||ŒSdS(s® Register a regular python function that can be executed by the python interpreter and can be compiled into a nopython function when referenced by other jit'ed functions. Can be used as:: @register_jitable def foo(x, y): return x + y Or, with compiler options:: @register_jitable(_nrt=False) # disable runtime allocation def foo(x, y): return x + y cs+tˆdˆdtƒ‡fd†ƒ}ˆS(NR3R/csˆS(N((targstkwargs(tfn(s.lib/python2.7/site-packages/numba/extending.pytov_wrapxs(R4tFalse(R7R8(R6(R7s.lib/python2.7/site-packages/numba/extending.pytwrapvs'N((R5R6R:((R6s.lib/python2.7/site-packages/numba/extending.pytregister_jitableescs)ddlm‰‡‡‡fd†}|S(s A decorator marking the decorated function as typing and implementing attribute *attr* for the given Numba type in nopython mode. Here is an example implementing .nbytes for array types:: @overload_attribute(types.Array, 'nbytes') def array_nbytes(arr): def get(arr): return arr.size * arr.itemsize return get i(t make_overload_attribute_templatecs ˆˆˆ|ƒ}t|ƒ|S(N(R(R-R (tattrR<ttyp(s.lib/python2.7/site-packages/numba/extending.pyR#“s (R$R<(R>R=R#((R=R<R>s.lib/python2.7/site-packages/numba/extending.pytoverload_attributeƒscs)ddlm‰‡‡‡fd†}|S(ss A decorator marking the decorated function as typing and implementing attribute *attr* for the given Numba type in nopython mode. Here is an example implementing .take() for array types:: @overload_method(types.Array, 'take') def array_take(arr, indices): if isinstance(indices, types.Array): def take_impl(arr, indices): n = indices.shape[0] res = np.empty(n, arr.dtype) for i in range(n): res[i] = arr[indices[i]] return res return take_impl i(tmake_overload_method_templatecs ˆˆˆ|ƒ}t|ƒ|S(N(R(R-R (R=R@R>(s.lib/python2.7/site-packages/numba/extending.pyR#¯s (R$R@(R>R=R#((R=R@R>s.lib/python2.7/site-packages/numba/extending.pytoverload_method›scsñddlm}ddlm‰ddlm‰ddlm‰ddlm ‰t ˆt ƒ sst ˆt jƒ r‰tdˆfƒ‚n‡‡‡fd†‰td |f‡‡‡fd †ƒYƒ}tˆˆƒ‡‡‡‡fd †ƒ}d S( sÅ Make an automatic attribute wrapper exposing member named *struct_attr* as a read-only attribute named *python_attr*. The given *typeclass*'s model must be a StructModel subclass. i(tAttributeTemplate(tdefault_manager(t StructModel(timpl_ret_borrowed(tcgutilss+typeclass should be a Type subclass, got %scsAˆj|ƒ}t|ˆƒs4td|fƒ‚n|jˆƒS(sF Get the Numba type of member *struct_attr* in *typ*. sKmake_struct_attribute_wrapper() needs a type with a StructModel, but got %s(tlookupR%R'tget_member_fe_type(R>tmodel(RDRCt struct_attr(s.lib/python2.7/site-packages/numba/extending.pytget_attr_fe_typeÇs tStructAttributecs eZˆZ‡‡fd†ZRS(cs|ˆkrˆ|ƒSdS(N((RR>R=(RKt python_attr(s.lib/python2.7/site-packages/numba/extending.pytgeneric_resolveÕs (R(t __module__RRN((RKRMt typeclass(s.lib/python2.7/site-packages/numba/extending.pyRLÑscsLˆj|ƒ||d|ƒ}ˆ|ƒ}t|ˆƒ}ˆ||||ƒS(Ntvalue(tcreate_struct_proxytgetattr(RtbuilderR>tvaltattrtytattrval(RFRKRERJ(s.lib/python2.7/site-packages/numba/extending.pytstruct_getattr_implÙs N(R$RBt datamodelRCtdatamodel.modelsRDttargets.imputilsREtRFR%Rt issubclassRtTypeR'RR(RPRJRMRBRLRX((RDRFRCRKRERMRJRPs.lib/python2.7/site-packages/numba/extending.pytmake_attribute_wrapper·s# "t _IntrinsiccBs‰eZdZejƒZejdej ƒZ d Z d„Z ed„ƒZd„Zd„Zd„Zd„Zd„Zed „ƒZRS( s& Dummy callable for intrinsic tmaxlencCs||_||_dS(N(t_namet_defn(RRtdefn((s.lib/python2.7/site-packages/numba/extending.pyt__init__ìs cCs;|j}|dkr7ttjƒƒ}|j|ƒn|S(s­ An instance-specific UUID, to avoid multiple deserializations of a given instance. Note this is lazily-generated, for performance reasons. N(t_Intrinsic__uuidtNoneR&tuuidtuuid1t _set_uuid(Rtu((s.lib/python2.7/site-packages/numba/extending.pyt_uuidðs   cCs?|jdkst‚||_||j|<|jj|ƒdS(N(RfRgtAssertionErrort_memot_recenttappend(RRk((s.lib/python2.7/site-packages/numba/extending.pyRjþs  cCsRddlm}m}|||j|jƒ}t|ƒ||tj|ƒƒdS(Ni(tmake_intrinsic_templateR(R$RqRRcRbRRR(RRqRR ((s.lib/python2.7/site-packages/numba/extending.pyt _registers cOsdj|ƒ}t|ƒ‚dS(sP This is only defined to pretend to be a callable from CPython. s {0} is not usable in pure-pythonN(tformattNotImplementedError(RR5R6tmsg((s.lib/python2.7/site-packages/numba/extending.pyt__call__ scCsdj|jƒS(Ns(RsRb(R((s.lib/python2.7/site-packages/numba/extending.pyt__repr__scsPddlm‰‡fd†}ˆj|jt|jƒ|j||jƒffS(Niÿÿÿÿ(t serializecsˆj|ƒ}ˆj||ƒS(N(t#_get_function_globals_for_reductiont_reduce_function(R7tgs(Rx(s.lib/python2.7/site-packages/numba/extending.pyt reduce_funcs(tnumbaRxt_rebuild_reductiont __class__R&RlRbRc(RR|((Rxs.lib/python2.7/site-packages/numba/extending.pyt __reduce__s cCssddlm}y|j|SWnMtk rn|j|Œ}|d|d|ƒ}|jƒ|j|ƒ|SXdS(Niÿÿÿÿ(RxRRd(R}RxRntKeyErrort_rebuild_functionRrRj(tclsRhRt defn_reducedRxRdtllc((s.lib/python2.7/site-packages/numba/extending.pyt_rebuild s   N(R(ROt__doc__tweakreftWeakValueDictionaryRnt collectionstdequeRtFUNCTION_CACHE_SIZERoRgRfRetpropertyRlRjRrRvRwR€t classmethodR†(((s.lib/python2.7/site-packages/numba/extending.pyR`ás       cs6‡fd†‰ˆsˆ|ŒS‡fd†}|SdS(su A decorator marking the decorated function as typing and implementing *func* in nopython mode using the llvmlite IRBuilder API. This is an escape hatch for expert users to build custom LLVM IR that will be inlined to the caller. The first argument to *func* is the typing context. The rest of the arguments corresponds to the type of arguments of the decorated function. These arguments are also used as the formal argument of the decorated function. If *func* has the signature ``foo(typing_context, arg0, arg1)``, the decorated function will have the signature ``foo(arg0, arg1)``. The return values of *func* should be a 2-tuple of expected type signature, and a code-generation function that will passed to ``lower_builtin``. For unsupported operation, return None. Here is an example implementing a ``cast_int_to_byte_ptr`` that cast any integer to a byte pointer:: @intrinsic def cast_int_to_byte_ptr(typingctx, src): # check for accepted types if isinstance(src, types.Integer): # create the expected type signature result_type = types.CPointer(types.uint8) sig = result_type(types.uintp) # defines the custom code generation def codegen(context, builder, signature, args): # llvm IRBuilder code here [src] = args rtype = signature.return_type llrtype = context.get_value_type(rtype) return builder.inttoptr(src, llrtype) return sig, codegen cs8t|dt|ƒƒ}t||ˆ}|jƒ|S(NR((RSR&R`Rr(R!RR…(R6(s.lib/python2.7/site-packages/numba/extending.pyt _intrinsicTs cs ˆ|ƒS(N((R!(R(s.lib/python2.7/site-packages/numba/extending.pytwrapper`sN((R5R6R((RR6s.lib/python2.7/site-packages/numba/extending.pyt intrinsic/s % cCs t||ƒS(sþ Get the address of a Cython function. Args ---- module_name: Name of the Cython module function_name: Name of the Cython function Returns ------- A Python int containing the address of the function (R(t module_namet function_name((s.lib/python2.7/site-packages/numba/extending.pytget_cython_function_addresses(*tinspectRhRˆRŠR}RRt typing.typeofRR$RRR[RRRRR R RYR R tregister_modelt pythonapiR RRRt _helperlibRR*tTrueR0R4R;R?RAR_tobjectR`R‘R”(((s.lib/python2.7/site-packages/numba/extending.pyts(    ."  0    *N 6