o 8ήc@s dZddlmZmZddlZddlZddlZddlZddl m Z ddl m Z ddl mZmZddlZddlm Z mZmZddlmZmZmZdd lmZe d d ZGd d d eZddZd=ddZddZddZ GdddeZ!Gddde!Z"Gddde!Z#Gddde!Z$GdddeZ%Gd d!d!e"Z& "d>d#d$Z'Gd%d&d&eZ(Gd'd(d(e(e"Z)d)d*Z*Gd+d,d,eZ+Gd-d.d.e(e+Z,Gd/d0d0e,Z-d"e,fd1d2Z. "d>d3d4Z/d5d6Z0Gd7d8d8eZ1Gd9d:d:eZ2Gd;d<ds zSignature.replacecCs|j|j|j|jfS). Needed because of __slots__. rr#rrr __getstate__IszSignature.__getstate__cCs|\|_|_|_|_dS)r*Nr)rstaterrr __setstate__OszSignature.__setstate__cCst|j|jfSr)hashrrr#rrr __hash__UzSignature.__hash__cCs>t|tr|j|jko|j|jko|j|jko|j|jkSdSr)rrrrrrrotherrrr __eq__Xs     zSignature.__eq__cCs ||k Srrr1rrr __ne___ zSignature.__ne__cCsd|j|jfS)Nz%s -> %s)rrr#rrr __repr__br0zSignature.__repr__cCs |jduS)za Whether this signature represents a bound method or a regular function. Nrr#rrr is_methodes zSignature.is_methodcCsl|jdur|St|jg|jddRd|jdi}t|jjdd}|jt j ||jj dd}|S)zE Convert this signature to a bound method signature. Nrr) parametersreturn_annotationr) r signaturerrrrr:valuesr)r pySignaturer;)rsigparamsrrr as_methodms zSignature.as_methodcCs.|jdur|St|jg|jf|jR}|S)zI Convert this signature to a regular function signature. N)rr=rrrr@rrr as_functions zSignature.as_functioncCs t|S)zH Convert this signature to a first-class function type. )rrr#rrr as_types zSignature.as_typecCs"tt|jgttj|jRSr)r=r unliteralrmaprr#rrr __unliteral__s zSignature.__unliteral__cCs|j}t|dt|jd|dt|d|jD] }|j|ddqt|d|jj|ddt|ddS) NzDUMP z [type code: ]z Argument types:z | )tabz Return type:zEND DUMP)rE_codeprinttype__name__rdumpr)rrKcarrr rPs   zSignature.dumpcCs$|jD] }|s dSq|jS)NF)r is_preciser)ratyperrr rSs  zSignature.is_preciser)rI)rO __module__ __qualname____doc__ __slots__r!propertyrrrrr)r+r-r/r3r4r6r8rBrDrErHrPrSrrrr rs6          rcCs"tf}t|t|d}t|||S)N)keycases)ConcreteTemplater%rrN)namerZ signatures baseclassesgvarsrrr make_concrete_templates racs6fdd}d|f}tf}t|||d}t|||S)zK Create a callable template with the given key and typer function. csSrrr#typerrr genericsz'make_callable_template..genericz%s_CallableTemplate)rZrdr)CallableTemplater%rN)rZrcrrdr]bases class_dictrrbr make_callable_templates   rhcOs"|dd}|r Jt|||dS)Nrr7)popr)rrkwsrrrr r=s r=cst|tr t|}|j}g}|D]\}} | j| jkr!||q|r.|dt| } n|} | } |rIt |D]\} } |t|| | | <q:|j | i| t |j D]b\}}|j }|j}|j|jkr|jvrj|}t|dkrt|dtjtjfrt|d}nd}||||}|j|<qX|jvr|||j|j|<qX||jusJ||||j|<qXtfdd|j D}|S)a Given the signature *pysig*, explicit *args* and *kws*, resolve omitted arguments and keyword arguments. A tuple of positional arguments is returned. Various handlers allow to process arguments: - normal_handler(index, param, value) is called for normal arguments - default_handler(index, param, default) is called for omitted arguments - stararg_handler(index, param, values) is called for a "*args" argument Nr9rrc3s|] }j|jVqdSr) argumentsr]).0parambarr sz!fold_arguments..)rrr%r:itemskind KEYWORD_ONLYappendlencopy enumeratebindr>r]defaultVAR_POSITIONALrkr StarArgTupleStarArgUniTuplerempty)rrrjnormal_handlerdefault_handlerstararg_handlerrAkwonlyr]p bind_argsbind_kwsidxnirmryargvaloutrrnr fold_argumentssP             rc@sXeZdZdZdZdZiZddZddZddZ e d d Z e d d Z d dZeZdS)FunctionTemplateTFcC ||_dSrcontextrrrrr r! r5zFunctionTemplate.__init__cCs.|j|jd}|jj|j|||fi|}|S)N)unsafe_castingexact_match_required)rrrresolve_overloadrZ)rr[rrjoptionsselectedrrr _selectszFunctionTemplate._selectcCs,t|j}t|tr|jdusJ|j}|S)y Return the key for looking up the implementation for the given signature on the target context. N)rNrZrrim_selfim_func)rr@rZrrr get_impl_keys  zFunctionTemplate.get_impl_keycCsNz t|\}}Wn tyd}d}Ynwt|}|dur"d}|||fS)aH Gets the source information about function impl. Returns: code - str: source code as a string firstlineno - int: the first line number of the function impl path - str: the path to file containing impl if any of the above are not available something generic is returned z#None available (built from string?)rNz (built from string?))inspectgetsourcelinesOSError getsourcefile)clsimplcode firstlinenopathrrr get_source_code_info&s    z%FunctionTemplate.get_source_code_infocCsdS)a Returns a dictionary with information specific to the template that will govern how error messages are displayed to users. The dictionary must be of the form: info = { 'kind': "unknown", # str: The kind of template, e.g. "Overload" 'name': "unknown", # str: The name of the source function 'sig': "unknown", # str: The signature(s) of the source function 'filename': "unknown", # str: The filename of the source function 'lines': ("start", "end"), # tuple(int, int): The start and end line of the source function. 'docstring': "unknown" # str: The docstring of the source function } Nrr#rrr get_template_info<sz"FunctionTemplate.get_template_infocCs8|}|dd|dd}d|jjd|dS)Nfilename:linesr< >)r __class__rO)rinfosrcinforrr __str__NszFunctionTemplate.__str__N)rOrUrVrrprefer_literalmetadatar!rr classmethodrrrrr6rrrr rs   rc@ eZdZdZddZddZdS)AbstractTemplatez Defines method ``generic(self, args, kws)`` which compute a possible signature base on input types. The signature does not have to match the input types. It is compared against the input types afterwards. cCs|t|d}|||}|durt|tstd|t||s.cSt|tjr |jS|SrrrrrNrrrr unpack_optj z*AbstractTemplate.apply..unpack_opt) getattrrrAssertionErrorformatrNanyrrG)rrrjrdr@rrrr apply]s     zAbstractTemplate.applycCszt|d}tjtjtj}||\}}}tt |}dt|d|j |tj ||d||t |df|j d}|S)NrdoverloadrVstartr9rrr]r@rr docstring)rosrdirnamenumba__file__rstrr pysignaturerO safe_relpathrurWrrbasepathrrrr@rrrr rvs   z"AbstractTemplate.get_template_infoNrOrUrVrWrrrrrr rVs rc@s$eZdZdZdZddZddZdS)reay Base class for a template defining a ``generic(self)`` method returning a callable to be called with the actual ``*args`` and ``**kwargs`` representing the call signature. The callable has to return a return type, a full signature, or None. The signature does not have to match the input types. It is compared against the input types afterwards. Nc Cst|d}|}t|}z |j|i|Wnty*}ztt||d}~ww||i|}|durWtdd|DrQdd}tt ||}||i|}|durWdSz|j } Wnt yjt |} Ynw| j|i|} | jrztdt|tst|tjstd|ft|g| jR}|jdur|j|jd}t| jt| jkrt| jdt| j} | j| d } |j| d }|g} || | j| jS) Nrdcsrrrrrrr rprz)CallableTemplate.apply..cSrrrrrrr rrz*CallableTemplate.apply..unpack_optzunsupported call signaturez1invalid return type for callable template: got %rr7r:r<)rrr=rx TypeErrorr rrrrGrAttributeErrorr rr'rrrTyperrr)rur:r>r) rrrjrdrc match_siger@rrboundr:r[rrr rsN         zCallableTemplate.applycCst|d}tjtjtj}||\}}}tt |}dt|j dt|d|j |tj ||d||t |df|jd}|S)NrdrrOrVrr9r)rrrrrrrrr rrZrOrrurWrrrr rs    z"CallableTemplate.get_template_info)rOrUrVrWrrrrrrr res  8rec@r)r\zg Defines attributes "cases" as a list of signature to match against the given input types. cCst|d}||||S)Nr[)rr)rrrjr[rrr rs zConcreteTemplate.applycCsRddl}t|jdd}t||d}d}|dur|j|urd}||ddddd}|S)NrrOunknownzType restricted functionzoperator overload)rrr)operatorrrZ)rrr]op_funcrrrrrr rs  z"ConcreteTemplate.get_template_infoNrrrrr r\s r\cseZdZfddZZS)_EmptyImplementationEntrycstt|d|dS)Nz_EmptyImplementationEntry({!r}))superrr!r)rreasonrrr r!s z"_EmptyImplementationEntry.__init__)rOrUrVr! __classcell__rrrr rsrc@sTeZdZdZddZddZddZdd Zd d Zd d Z e ddZ ddZ dS)_OverloadFunctionTemplatez; A base class of templates for overload functions. cCst|}t|}dd}||\}}}||\} } } d} | ||f} d}|}| }|r9| s8d|| f}t|n2| rk| d| | }z|d||dd}Wntyjd}||| |df}t|wd d }||krd | |||f}t||d d |D}dd | D}||krd}||| ||| f}t|dd |Ddd | Dk}|sd}||| ||| f}t|dS)NcSs|g}g}d}|jD]-}|jtjjkr3|||jtjjkr#|}q |jtjj kr2d}t ||q ||q |||fS)NzXThe use of VAR_KEYWORD (e.g. **kwargs) is unsupported. (offending argument name is '%s')) r:r>ryr pyParameterr}rtrrrz VAR_KEYWORDr )r@rjrpos_argrmsgrrr get_args_kwargss    zA_OverloadFunctionTemplate._validate_sigs..get_args_kwargsz9Typing signature: %s Implementation signature: %sz.Typing and implementation arguments differ in zVAR_POSITIONAL (e.g. *args) argument kind (offending argument name is '%s') found in the typing function signature, but is not in the implementing function signature. %sr9z)argument names. %s First difference: '%s'cSst|t|A}d|S)NzDifference: %s)set)typing implementingdiffrrr gen_diffJsz:_OverloadFunctionTemplate._validate_sigs..gen_diffzargument names. %s %scSg|]}|jqSrr]rrrr Sz<_OverloadFunctionTemplate._validate_sigs..cSrrrrrrr rTrzkeyword argument names. %s %scSrr)ryrrrr rYrz&keyword argument default values. %s %s)r rr index ValueError)r typing_func impl_func typing_sigimpl_sigrty_argsty_kwsty_posim_argsim_kwsim_possig_fmtsig_str err_prefixrRbr specializedrtyimsamerrr _validate_sigssT     z(_OverloadFunctionTemplate._validate_sigsc Csddlm}|||\}}|durdSt|}|jjsddlm}m }ddl m } |j } | } | jj} | jj} | | | ddd| d}| | | | j|| d}|jj}|||\}}}}|j|jjdd}||j| ||d\}}}}||}tjj|j|_t ||d}d|i|j!|j"<t#d }||j$|j"<|jj%s|&|j||}|'||j$|j"<t(||||}||d |j!|j"<|S|&|j||}|durdS|'||j$|j"<|S) zv Type the overloaded function by compiling the appropriate implementation for the given args. r)PreLowerStripPhisN) typed_passescompiler) InlineWorkerT) enable_ssa folded_argszalways inlined)r iinfo))numba.core.typed_passesr _get_implr Dispatcher_inlineis_never_inline numba.corerr numba.core.inline_closurecallr  _compilerFlags targetdescrtyping_contexttarget_contextpipeline_classlocals dispatcherget_call_templaterun_untyped_passespy_functype_inference_stager_strip_phi_nodesrcoreir_utilsbuild_definitionsblocks _definitionsr_inline_overloadsrr_compiled_overloadsis_always_inline get_call_type get_overload _inline_info)rrrjrdispnew_args disp_typerr r fcompflagstyctxtgctx compiler_inst inline_workerresolvetemplaterr irtypemapr calltypes_r@ impl_initr rrr rd_sd         z!_OverloadFunctionTemplate.genericcCsjtj}|jt|t||f}z |j|\}}||fWSty'Ynw||||\}}||fS)zGet implementation given the argument types. Returning a Dispatcher object. The Dispatcher object is cached internally in `self._impl_cache`. ) r ConfigStack top_or_nonerrrq _impl_cacheKeyError _build_impl)rrrjr1 cache_keyrrrr rs   z#_OverloadFunctionTemplate._get_implc s|jdd}|durddlmfdd}n7ddlm}m}m}||d}|durO||d}|dur?d}t| |||j }t ||sKd }||}|durWtd |S) z4Gets a jit decorator suitable for the current targettargetNrjitcs|ddi|S)NnopythonTr)rr'rDrr rz>_OverloadFunctionTemplate._get_jit_decorator..)target_registryget_local_target jit_registry)z!Unknown target '{}', has it been z registered?z0No overloads exist for the requested target: {}.z$Cannot find a suitable jit decorator) rgetrrEnumba.core.target_extensionrHrIrJrrr issubclass) r jitter_strjitterrHrIrJ target_classr target_hwrrDr _get_jit_decorators$     z,_OverloadFunctionTemplate._get_jit_decoratorc Cs|}t|j}z |j|i|Wnty'}ztt||d}~ww|j|i|}|dur;d|j|<dSt |t rL|\}} |j }i}d}n|} t | t s\d} t | | |jrf||j| |di|j} | | } t| } | |j|||dur| |f|j|<| |fS)aNBuild and cache the implementation. Given the positional (`args`) and keyword arguments (`kws`), obtains the `overload` implementation and wrap it in a Dispatcher object. The expected argument types are returned for use by type-inference. The expected argument types are only different from the given argument types if there is an imprecise type in the given argument types. Parameters ---------- cache_key : hashable The key used for caching the implementation. args : Tuple[Type] Types of positional argument. kws : Dict[Type] Types of keyword argument. Returns ------- disp, args : On success, returns `(Dispatcher, Tuple[Type])`. On failure, returns `(None, None)`. NNNzOImplementation function returned by `@overload` has an unexpected type. Got {}r)rRrr=_overload_funcrxrr rr?rrrrrr_strictr _jit_optionsrrr*r)rrBrrjrOov_sigr ovf_resultr@pyfuncrjitdecorr-r/rrr rAs<     z%_OverloadFunctionTemplate._build_implcC |j|jSr)r(rrCrrr r= z&_OverloadFunctionTemplate.get_impl_keycCvtjtjtj}|j}||\}}}tt |}dt |d|j |tj ||d||t |df|jd}|S)aReturn a dictionary with information about the source code of the implementation. Returns ------- info : dict - "kind" : str The implementation kind. - "name" : str The name of the function that provided the definition. - "sig" : str The formatted signature of the function. - "filename" : str The name of the source file. - "lines": tuple (int, int) First and list line number. - "docstring": str The docstring of the definition. rrVrr9rrrrrrrTrrr rrrOrrurW)rrrrrrr@rrrr get_source_infoDs  z)_OverloadFunctionTemplate.get_source_infocCr^)NrrVrr9rr_rrrrrrr@rrrr rg  z+_OverloadFunctionTemplate.get_template_infoN) rOrUrVrWrrdrrRrArrr`rrrrr rsZ[(I  "rFc KsXt|dt|}d|f}t} t|t|ii||tt|i||d } t| || f| S)z Make a template class for function *func* overloaded by *overload_func*. Compiler options are passed as a dictionary to *jit_options*. rOzOverloadTemplate_%s) rZrTr?r(rVrUrr'rr)rrrr% staticmethodrrN) func overload_func jit_optionsstrictinlinerr' func_namer]basedctrrr make_overload_templatews   rlc@seZdZdZddZdS)_TemplateTargetHelperMixinzDMixin for helper methods that assist with target/registry resolutionc Cslddlm}m}|jdd}||j||}||}|jj}|t |j vr+t }|St |j } t | }|S)aReturns the registry for the current target. Parameters ---------- reason: str Reason for the resolution. Expects a noun. Returns ------- reg : a registry suitable for the current target. r)_get_local_target_checkeddispatcher_registryrCrd) rLrnrorrKrrrrefreshbuiltin_registry _registriesiternext) rrrnrohwstrrQr-tgtctxreg registriesrrr _get_target_registrys   z/_TemplateTargetHelperMixin._get_target_registryN)rOrUrVrWryrrrr rms rmc@s(eZdZdZddZddZddZdS) _IntrinsicTemplatez< A base class of templates for intrinsic definition c Cs|dj}|j|t|f}z|j|WStyYnw|j|jg|Ri|}|dur3dS|\}}t |j}t |j dd} |j |j | dd}||j|<||j|j<||g|jR||S)z6 Type the intrinsic by the arguments. intrinsicNr9rr<)rylowerrrrqr?r@_definition_funcr rrr:r>r)_overload_cacher) rrrj lower_builtinrBresultr@imprr:rrr rds$      z_IntrinsicTemplate.genericcCr[r\)r~rrCrrr rr]z_IntrinsicTemplate.get_impl_keycCr^)Nr{rVrr9r)rrrrrr}rrr rrrOrrurWrarrr rrbz$_IntrinsicTemplate.get_template_infoN)rOrUrVrWrdrrrrrr rzs  rzcCs4t}d|}t|t|ii|d}t|||f|S)z Make a template class for a intrinsic handle *handle* defined by the function *defn*. The *name* is used for naming the new template class. z_IntrinsicTemplate_%s)rZr}r?r~r)rzr%rcrN)handledefnr]r'rjrkrrr make_intrinsic_templates  rc@s(eZdZddZddZddZeZdS)AttributeTemplatecCrrrrrrr r!r5zAttributeTemplate.__init__cCs |||Sr)_resolve)rvalueattrrrr r6s zAttributeTemplate.resolvecCsVt|d|d}|dur'|j}|tur"t|tjr |j||SdS|||S||S)Nz resolve_%s)rgeneric_resolveNotImplementedrrModulerresolve_module_constants)rrrfnrrr rs  zAttributeTemplate._resolveN)rOrUrVr!r6rrrrrrr rs rcsLeZdZdZdZfddZddZddZed d Z ed d Z Z S) _OverloadAttributeTemplatezF A base class of templates for @overload_attribute functions. Fcs"tt||||_|dSr)rrr!r _init_oncerrrr r!s z#_OverloadAttributeTemplate.__init__cs6t|j}|dj}|j|fdd}dS)N attributecs<|j}||}|||fi}|||}|||fSr)r_get_function_type_get_signature get_function)rbuildertypr typingctxfntyr@callrrr getattr_impl&s    z;_OverloadAttributeTemplate._init_once..getattr_impl)rN_attrry lower_getattrrZ)rrrrrrr r s   z%_OverloadAttributeTemplate._init_oncecCsP|j|krdS||j|}||j||fi}|jD] }|j|jq|jSr)rrrr templatesr'r&r)rrrrr@r7rrr r.s  z#_OverloadAttributeTemplate._resolvecCs&||||}|jt|jd}|SNr<)r*r)r rrT)rrrrrjr@rrr r8sz)_OverloadAttributeTemplate._get_signaturecCs ||jSr)resolve_value_typerT)rrrrrr r>s z-_OverloadAttributeTemplate._get_function_type) rOrUrVrWr8r!rrrrrrrrrr rs  rc@s$eZdZdZdZddZddZdS)_OverloadMethodTemplatezC A base class of templates for @overload_method functions. Tcs\j}zd}Wn tyYdSw|j}|j|fjttjfdd}dS)z. Overriding parent definition methodcsV|jd}|j}||}|||ji}|||}|t|dd|||S)Nrlibsr)rrrrradd_linking_libsr)rrr@rrrrrr#rr method_implWs    z7_OverloadMethodTemplate._init_once..method_implN)rryr r|rZrVarArgAny)rrregistryrrrr#r rIs z"_OverloadMethodTemplate._init_oncecs^jkrdSttjrjksJntjsJGfdddt}t|S)Ncs@eZdZjfZjZejZjZjZfddZ dS)z8_OverloadMethodTemplate._resolve..MethodTemplatecspft|}j}j|||}|jtjd}|jD] }j |j q$|dur6| SdSr) rrrrr)r rrTrr'r&rB)r;rrjrr@r7)rrrr rdrs z@_OverloadMethodTemplate._resolve..MethodTemplate.genericN) rOrUrVrZrrcrTr'rrdrrrrrr MethodTemplateks  r)rrrTypeRefrZr BoundFunction)rrrrrrr rbs   z _OverloadMethodTemplate._resolveN)rOrUrVrWr8rrrrrr rCs  rc Ksbt|tjst|tjsJd||f}t||itt|it|||d}t|||f|} | S)z` Make a template class for attribute *attr* of *typ* overloaded by *overload_func*. zOverloadAttributeTemplate_%s_%s)rZrr?rr'rTrr)rrrrMr%rcrrN) rrrerhrrjr'r]rkobjrrr make_overload_attribute_templates  rcKst|||f|t|d|S)z] Make a template class for method *attr* of *typ* overloaded by *overload_func*. )rhrjr)rr)rrrerhrr'rrr make_overload_method_templatesrcsfdd}|S)aq Wrap an AttributeTemplate resolve_* method to allow it to resolve an instance method's signature rather than a instance attribute. The wrapped method must return the resolved method's signature according to the given self type, args, and keywords. It is used thusly: class ComplexAttributes(AttributeTemplate): @bound_function("complex.conjugate") def resolve_conjugate(self, ty, args, kwds): return ty *template_key* (e.g. "complex.conjugate" above) will be used by the target to look up the method's implementation, as a regular function. cstfdd}|S)Ncs&Gfdddt}t|S)Ncs eZdZZfddZdS)zSbound_function..wrapper..attribute_resolver..MethodTemplatecs0||}|dur|jdur|jd}|S)Nr7)rr))r;rrjr@)method_resolverrrrr rds z[bound_function..wrapper..attribute_resolver..MethodTemplate.genericN)rOrUrVrZrdr)rr template_keyrrr rsr)rrr)rrr)rr)rrr attribute_resolvers z;bound_function..wrapper..attribute_resolver) functoolswraps)rrr)rr wrappers zbound_function..wrapperr)rrrrr bound_functions rc@s2eZdZdZddZddZddZd d d ZdS) Registryz~ A registry of typing declarations. The registry stores such declarations for functions, attributes and globals. cCsg|_g|_g|_dSr functions attributesglobalsr#rrr r!s zRegistry.__init__cCt|tsJ|j||Sr)rMrrrtritemrrr register zRegistry.registercCrr)rMrrrtrrrr register_attrrzRegistry.register_attrNc s|durdus J|rJj|fdSfdddus%J|d|r/JurLtjj}t|jurLtd|jjffdd}|S)a# Register the typing of a global value. Functional usage with a Numba type:: register_global(value, typ) Decorator usage with a template class:: @register_global(value, typing_key=None) class Template: ... NcsDGfddd|}trt|}ntdj|f|S)NcseZdZZdS)z.decorate..TemplateN)rOrUrVrZr typing_keyrr Templatesrz%cannot infer type for global value %r)callablerFunctionrrrt)rrrr)rvalrr decorates  z*Registry.register_global..decoraterz'%r is not globally reachable as '%s.%s'cs |Srrr)rrrr decoratorr5z+Registry.register_global..decorator) rrtrisysmodulesrUrrOr)rrrr'modrr)rrrrr register_globals     zRegistry.register_globalrS)rOrUrVrWr!rrrrrrr rs rc@r)BaseRegistryLoadera An incremental loader for a registry. Each new call to new_registrations() will iterate over the not yet seen registrations. The reason for this object is multiple: - there can be several contexts - each context wants to install all registrations - registrations can be added after the first installation, so contexts must be able to get the "new" installations Therefore each context maintains its own loaders for each existing registry, without duplicating the registries themselves. cstfdd|jD|_dS)Nc3s$|] }|tt|fVqdSr)r stream_listr)rlr]rrr rps  z.BaseRegistryLoader.__init__..)r%registry_items_registrations)rrrrr r!s zBaseRegistryLoader.__init__ccs t|j|D]}|VqdSr)rtr)rr]rrrr new_registrationssz$BaseRegistryLoader.new_registrationsN)rOrUrVrWr!rrrrr rs rc@seZdZdZdZdS)RegistryLoaderz6 An incremental loader for a typing registry. rN)rOrUrVrWrrrrr r srr)F);rWabcrrrrros.pathr collectionsrcollections.abcrrrrrrr r numba.core.errorsr r r numba.core.cpu_optionsrr,objectrrarhr=rrrrer\rrrlrmrzrrrrrrrrrrrqrinferr infer_getattrr infer_globalrrrr sf     AX1Tz 54 .=   $A