a b@sddlmZddlZddlmZmZmZmZmZm Z ddlm Z m Z m Z ddl mZmZmZmZddlmZGd d d eZdS) )absolute_importN) ExprNodes PyrexTypes MemoryViewParseTreeTransformsStringEncodingErrors) CloneNode ProxyNode TupleNode) FuncDefNode CFuncDefNode StatListNodeDefNode) OrderedSetcseZdZdZdZdZdZdZdZe j gdZ fddZ ddZ dd Z d d Zd d ZddZddZddZddZddZddZddZddZdZdZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Z d.d/Z!d0d1Z"d2d3Z#d4d5Z$d6d7Z%d8d9Z&Z'S):FusedCFuncDefNodea This node replaces a function with fused arguments. It deep-copies the function for every permutation of fused types, and allocates a new local scope for it. It keeps track of the original function in self.node, and the entry of the original function in the symbol table is given the 'fused_cfunction' attribute which points back to us. Then when a function lookup occurs (to e.g. call it), the call can be dispatched to the right function. node FuncDefNode the original function nodes [FuncDefNode] list of copies of node with different specific types py_func DefNode the fused python function subscriptable from Python space __signatures__ A DictNode mapping signature specialization strings to PyCFunction nodes resulting_fused_function PyCFunction for the fused DefNode that delegates to specializations fused_func_assignment Assignment of the fused function to the function name defaults_tuple TupleNode of defaults (letting PyCFunctionNode build defaults would result in many different tuples) specialized_pycfuncs List of synthesized pycfunction nodes for the specializations code_object CodeObjectNode shared by all specializations and the fused function fused_compound_types All fused (compound) types (e.g. floating[:]) N)__signatures__resulting_fused_functionfused_func_assignmentcstt||jg|_||_t|jt}|r:||n | ||jD]L}|j j j r\J|j jj rjJ|jj r~|jj r~J|sJ|jjrJ|j jsJJqJ||j _|jdd|_dSN)superr__init__posnodesnode isinstancercopy_def copy_cdefentrytypeis_fused local_scope return_typecfunc_declaratoroptional_arg_countZ op_arg_structfused_cfunctionstats)selfrenvis_defn __class__i/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/Cython/Compiler/FusedNode.pyr2s       zFusedCFuncDefNode.__init__cCstdd|jjD}||}t|}||_|jj|jvrP|j |jj|D]\}}t |j}|jjj |j_ | |j||jj||_||||||||||jj||t|j|d|j_|j|j|jj<||sTqqT|j|_|j|j|dd|_dS)zh Create a copy of the original def or lambda function for specialized versions. cSsg|]}|jjr|jqSr/r!r".0argr/r/r0 Uz.FusedCFuncDefNode.copy_def..Tr+N)runiquerargs_get_fused_base_types get_all_specialized_permutationsfused_compound_typesr pyfunc_entriesremovecopydeepcopy signature_specialize_function_argsr$ specializeanalyse_declarationscreate_new_local_scopespecialize_copied_defspecialize_entryusedentriesnamereplace_fused_typechecks orig_py_funcmake_fused_cpdefpy_func)r)r*r< fused_types permutationscnamefused_to_specific copied_noder/r/r0rOs6      zFusedCFuncDefNode.copy_defcCs|jj}|jj|_}d|j_|r4|j|j|jj}||_ g}|D]`\}}t |j}|j |} |j} | | |t|jD]N\} } | j| jkr| | jr|j| |_|jjs| j|j_|j} | j} qq|| | |_| | | _| _| jp|jjjp|jp| j| _|jjjr>|jjj| ||d| j|_||||||jj||||jr|j|jj| |j||jjj!|||"|sNqqNz|j#|jj} Wn t$y|j%|Yn0||j| | d<|r|j&||dd|_n||_dS)zf Create a copy of the original c(p)def function for all specialized versions. N)Z fused_cnamerFr7)'rr!r;rNrLr=r>r get_fused_typesr<r?r@rCrG enumerateZ cfunc_entriesrQZsame_as_resolved_type func_cnameappendrHZdefined_in_pxdZis_c_class_scopeZ is_cmethodr%r&Zdeclare_optional_arg_structr$rErBr9Zdeclare_cpdef_wrapperrF as_variablerKindex ValueErrorextendrM)r)r*rPrLrOZnew_cfunc_entriesrQrRrSr!r iZ orig_entryZcindexr/r/r0rxsv             zFusedCFuncDefNode.copy_cdefcCs&g}t}|D]}|j||dq|S)zq Get a list of unique basic fused types, from a list of (possibly) compound fused types. )resultseen)setrT)r)r<Z base_typesr^ fused_typer/r/r0r:s z'FusedCFuncDefNode._get_fused_base_typescCs:|D]0}|jjr|j||_|jjr|j|jqdSr)r!r"rCis_memoryviewsliceZvalidate_memslice_dtyper)r)r9rRr4r/r/r0rBs z+FusedCFuncDefNode._specialize_function_argscCs(||||j_d|_|j|dS)a Create a new local scope for the copied node and append it to self.nodes. A new local scope is needed because the arguments with the fused types are already in the local scope, and we need the specialized entries created after analyse_declarations on each specialized version of the (CFunc)DefNode. f2s is a dict mapping each fused type to its specialized version FN)Zcreate_local_scoper#rRZhas_fused_argumentsrrW)r)rr*f2sr/r/r0rEs z(FusedCFuncDefNode.create_new_local_scopecsT||}fdd|D}d||_t||jj|j_|j|j_|j|j_dS)zwSpecialize the copy of a DefNode given the copied node, the specialization cname and the original DefNode entrycsg|]}t|qSr/)rZspecialization_signature_string)r3r`rbr/r0r5sz;FusedCFuncDefNode.specialize_copied_def..|N) r:joinspecialized_signature_stringrZget_fused_cnamer pymethdef_cnamedoc doc_cname)r)rrQZpy_entryrbr<rOZ type_stringsr/rcr0rFs    z'FusedCFuncDefNode.specialize_copied_defcCs,tj}t|j}||tj|kr(dSdS)z Branch-prune fused type checks like if fused_t is int: ... Returns whether an error was issued and whether we should stop in in order to prevent a flood of errors. FT)r num_errorsrZReplaceFusedTypeChecksr#)r)rSrjZ transformr/r/r0rKs  z*FusedCFuncDefNode.replace_fused_typecheckscCs.|D]$}|jj||jd|dqdS)zl Generate Cython code for instance checks, matching an object to specialized types. ) py_type_namespecialized_type_namez if isinstance(arg, {{py_type_name}}): dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'; break N)contextupdaterkspecialization_string put_chunk)r) normal_typespyx_coder*specialized_typer/r/r0_fused_instance_checkssz(FusedCFuncDefNode._fused_instance_checkscCs|jrd|St|ddS)Nz ___pyx_%s _) is_typedefstrreplacer)dtyper/r/r0 _dtype_name&szFusedCFuncDefNode._dtype_namecCs|jr||St|Sr)rwr|rxrzr/r/r0 _dtype_type+s zFusedCFuncDefNode._dtype_typecCs|jr dSd||SdS)Nzsizeof(void *)z sizeof(%s))Z is_pyobjectr}rzr/r/r0 _sizeof_dtype0szFusedCFuncDefNode._sizeof_dtypecCs|dr&|d|d||drL|d|d||drr|d|d||dr|d|d |d S) z?Setup some common cases to match dtypes against specializationszif kind in b'iu':pass dtype_intzelif kind == b'f': dtype_floatzelif kind == b'c': dtype_complexzelif kind == b'O':Z dtype_objectN)indenterputlnnamed_insertion_pointdedentr)rrr/r/r0%_buffer_check_numpy_dtype_setup_cases6s             z7FusedCFuncDefNode._buffer_check_numpy_dtype_setup_casesz8dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'z!dest_sig[{{dest_sig_idx}}] = Nonec Cs||||D]}|}|jr&|j}|j}|jj||dd||||jd|j |j f|j |j f|j |jfg}|D]`\}} |r|d|jf} |j r| d7} |jr| d7} | d| r|| |j| d| q|qd S) zO Match a numpy dtype object to the individual specializations. z == itemsizez!not (%s_is_signed ^ dtype_signed))Zitemsize_matchZ signed_matchr{rlz3{{itemsize_match}} and (arg.ndim) == %dz and {{signed_match}}z and arg_is_pythran_compatiblezif %s:breakN)ris_pythran_expr org_bufferr{rmrnr~r|rois_intrZis_floatr is_complexrndimrrmatchr) r)rrZspecialized_buffer_types pythran_typesrsZ final_typer{ZdtypesZdtype_categoryZ codewriterZcondr/r/r0_buffer_check_numpy_dtypeNs:          z+FusedCFuncDefNode._buffer_check_numpy_dtypecCs~|j}|jrdg|j}n|j}t||}|||jj|j |d| d|jj|j | |d| d|jdS)z For each specialized type, try to coerce the object to a memoryview slice of that type. This means obtaining a buffer and parsing the format string. TODO: separate buffer acquisition from format parsing )directZstrided)Zcoerce_from_py_funcr{z;{{memviewslice_cname}} {{coerce_from_py_func}}(object, int))rlZ sizeof_dtypea # try {{dtype}} if itemsize == -1 or itemsize == {{sizeof_dtype}}: memslice = {{coerce_from_py_func}}(arg, 0) if memslice.memview: __PYX_XDEC_MEMVIEW(&memslice, 1) # print 'found a match for the buffer through format parsing' %s break else: __pyx_PyErr_Clear() N)r{ is_bufferraxesrZMemoryViewSliceTypeZcreate_from_py_utility_codermrnZfrom_py_functionrror~rpr)r)rr decl_codersr*r{rZ memslice_typer/r/r0!_buffer_parse_format_string_checkus,   z3FusedCFuncDefNode._buffer_parse_format_string_checkcCs|d|rdndd|rdndd|d|rB|d|d |||||d|D]}|||||qhd S) a^ Generate Cython code to match objects to buffer specializations. First try to get a numpy dtype object and match it against the individual specializations. If that fails, try naively to coerce the object to each specialization, which obtains the buffer each time and tries to match the format string. z z!arg_is_pythran_compatible = Falsez if ndarray is not None: if isinstance(arg, ndarray): dtype = arg.dtype z arg_is_pythran_compatible = TrueaC elif __pyx_memoryview_check(arg): arg_base = arg.base if isinstance(arg_base, ndarray): dtype = arg_base.dtype else: dtype = None else: dtype = None itemsize = -1 if dtype is not None: itemsize = dtype.itemsize kind = ord(dtype.kind) dtype_signed = kind == 'i' raS # Pythran only supports the endianness of the current compiler byteorder = dtype.byteorder if byteorder == "<" and not __Pyx_Is_Little_Endian(): arg_is_pythran_compatible = False elif byteorder == ">" and __Pyx_Is_Little_Endian(): arg_is_pythran_compatible = False if arg_is_pythran_compatible: cur_stride = itemsize shape = arg.shape strides = arg.strides for i in range(arg.ndim-1, -1, -1): if (strides[i]) != cur_stride: arg_is_pythran_compatible = False break cur_stride *= shape[i] else: arg_is_pythran_compatible = not (arg.flags.f_contiguous and (arg.ndim) > 1) Znumpy_dtype_checksN)rpindentrrrr)r) buffer_typesrrrrr*rsr/r/r0_buffer_checkss.      z FusedCFuncDefNode._buffer_checksc Cs|d|jd|r&|jd|jdt}t}|D]}|j}||} |jr| |vr|| |d| | | f|jj rBt ||vrB|t ||j j| ||d|jdqBdS) zr If we have any buffer specializations, write out some variable declarations and imports. z ctypedef struct {{memviewslice_cname}}: void *memview void __PYX_XDEC_MEMVIEW({{memviewslice_cname}} *, int have_gil) bint __pyx_memoryview_check(object) z cdef {{memviewslice_cname}} memslice cdef Py_ssize_t itemsize cdef bint dtype_signed cdef char kind itemsize = -1 zl cdef bint arg_is_pythran_compatible cdef Py_ssize_t cur_stride zq cdef type ndarray ndarray = __Pyx_ImportNumPyArrayTypeIfAvailable() zctypedef %s %s "%s") dtype_nameZ dtype_typez cdef bint {{dtype_name}}_is_signed {{dtype_name}}_is_signed = not (<{{dtype_type}}> -1 > 0) N)rplocal_variable_declarationsimportsr_r{r|rwaddrresolveZempty_declaration_coderrxrmrnr}) r)rrrall_buffer_typesrZ seen_typedefsZseen_int_dtypesZ buffer_typer{rr/r/r0_buffer_declarationssB       z&FusedCFuncDefNode._buffer_declarationsc Cst|j}|t}ggg}}}d}|D]f}|} | rp| |vrLq2|| | dkrdd}q||q2|jr||q2|j s|j r2||q2||||fS)zV Specialize fused types and split into normal types and buffer types. FobjectT) rZget_specialized_typesr!sortr_rkrrWrrra) r)r4Zspecialized_typesZseen_py_type_namesrqrrhas_object_fallbackrsrkr/r/r0_split_fused_typess&      z$FusedCFuncDefNode._split_fused_typescCs|ddS)Na # PROCESSING ARGUMENT {{arg_tuple_idx}} if {{arg_tuple_idx}} < len(args): arg = (args)[{{arg_tuple_idx}}] elif kwargs is not None and '{{arg.name}}' in kwargs: arg = (kwargs)['{{arg.name}}'] else: {{if arg.default}} arg = (defaults)[{{default_idx}}] {{else}} {{if arg_tuple_idx < min_positional_args}} raise TypeError("Expected at least %d argument%s, got %d" % ( {{min_positional_args}}, {{'"s"' if min_positional_args != 1 else '""'}}, len(args))) {{else}} raise TypeError("Missing keyword-only argument: '%s'" % "{{arg.default}}") {{endif}} {{endif}} )rprr/r/r0_unpack_argument2sz"FusedCFuncDefNode._unpack_argumentcCs*ddlm}m}m}|dd|jjD}tj|jjt ||rP|jj |jj nt dd|jjD|j jd}|j|d} |j|d} | d | | d | | d | d | d d} d} t} t}t|jjD]L\}}|jjr&|j}t |dkrtd|d}|jjr*||vr*|||j||| | d||\}}}}|| | dr|r||| ||s|r| |j!dd|"||| | ||r| j#jdd| $|j%n | $|j&| $d| '| d7} | || dd|D|j(r| d7} q| rx|)| | | || |j!dd| |j!dd| d| *}ddl+m,}|j|d|gd}|-|jj.|j/}|0| *|1||_2|3||j4d}|j2|_5t6|jt7r|j8d d |_9nd!d|j8D|_9|S)"a! This creates the function that is indexable from Python and does runtime dispatch based on the argument types. The function gets the arg tuple and kwargs dict (or None) and the defaults tuple as arguments from the Binding Fused Function's tp_call. r) TreeFragmentCode UtilityCodecSsg|]}|jjr|jqSr/r1r2r/r/r0r5Psz6FusedCFuncDefNode.make_fused_cpdef..css|]}|jdurdVqdS)Nr)defaultr2r/r/r0 Zr6z5FusedCFuncDefNode.make_fused_cpdef..)memviewslice_cname func_argsZn_fusedZmin_positional_argsrJ)rmz cdef extern from *: void __pyx_PyErr_Clear "PyErr_Clear" () type __Pyx_ImportNumPyArrayTypeIfAvailable() int __Pyx_Is_Little_Endian() a def __pyx_fused_cpdef(signatures, args, kwargs, defaults): # FIXME: use a typed signature - currently fails badly because # default arguments inherit the types we specify here! dest_sig = [None] * {{n_fused}} if kwargs is not None and not kwargs: kwargs = None cdef Py_ssize_t i # instance check body rZ func_defsrrzODetermination of more than one fused base type per argument is not implemented.)Z arg_tuple_idxr4Z dest_sig_idx default_idxzwhile 1:ZIsLittleEndianzModuleSetupCode.cr)rlrcss|] }|jVqdSr)r)r3tyr/r/r0rr6ImportzImportExport.cZImportNumPyArraya candidates = [] for sig in signatures: match_found = False src_sig = sig.strip('()').split('|') for i in range(len(dest_sig)): dst_type = dest_sig[i] if dst_type is not None: if src_sig[i] == dst_type: match_found = True else: match_found = False break if match_found: candidates.append(sig) if not candidates: raise TypeError("No matching signature found") elif len(candidates) > 1: raise TypeError("Function call with ambiguous argument types") else: return (signatures)[candidates[0]] )ConstantFoldingmodule)levelZpipelineNcSsg|] }|jqSr/rN)r3r,r/r/r0r5r6):rrrrr:rr9rrlenZnum_required_argsZnum_required_kw_argssumr rJZ PyxCodeWriterrprrrr_rUr!r"rTNotImplementedErrorrrnrrrrtZuse_utility_codeZ load_cachedrrmrrno_matchrrrgetvalueZOptimizerZSetPosTransformrrootZdeclare_declarations_in_scopeZ global_scopescoperDr(Zfragment_scoperrrZspecialized_cpdefs)r)rLr*r+rrrrOrmrrrZ fused_indexrrZseen_fused_typesr\r4Zarg_fused_typesr`rqrrrZ fragment_coderfragmentastrNr/r/r0rMGs                     z"FusedCFuncDefNode.make_fused_cpdefcCsd}|jj}|D]}t||t|jj|q|jj|j_|jj|j_|jddt |j t rl||j|j<n||j|j_ |j |||jj_|jD],}t |j t r|j|_q|j|j_||j_ q||j|jdS)N) rJrrQrVZ pyfunc_cnamergrhriZ is_memberrZ__pyx_fused_cpdef)rNr setattrgetattrrLrJrhrIpoprrrrXr=rWr'rZ fused_py_funcsynthesize_defnodesr(r)r)r*Zcopy_attributesr attrrr/r/r0update_fused_defnode_entrys*           z,FusedCFuncDefNode.update_fused_defnode_entryc Cs|jD].}|D] }|jD]}|jr||qqq|jrt|j||_|j||_|j||_|j ||_ g|_ }|j j D]4}|j r|j ||_ |t|j q|dqt|jD]X\}}||}|j|<t|trt|j |D]$\}} | durt| |j||_ qq|jrdd|D} t|j| d|_|jj|dd||_t|j|_t|jdj|_|jj} t|j| _t|j| _t|jD]6\}} t|j| _| |} |j|<t|j| _q|S)z Analyse the expressions. Take care to only evaluate default arguments once and clone the result for all specializations NcSsg|]}|rt|qSr/)r )r3rr/r/r0r5'r6z9FusedCFuncDefNode.analyse_expressions..)r9T)Z skip_childrenr) r<rTtypesrZcreate_declaration_utility_coderNranalyse_expressionsrrdefaultsrr9rrWr rUr(rr zipr Z coerce_tor!r rdefaults_tupleZ analyse_typesZcoerce_to_pyobjectspecialized_pycfuncs code_objectr4) r)r*Zfused_compound_typer`Zspecialization_typerr4r\statrr9Z fused_funcZpycfuncr/r/r0rsH           z%FusedCFuncDefNode.analyse_expressionscCst|jdtr"dd|jD}n|j}dd|D}ddt||D}dd|D}tj|jt|||_||_ |D] }d|_ qzdS) zT Create the __signatures__ dict of PyCFunctionNode specializations. rcSsg|] }|jqSr/rr3rr/r/r0r5<r6z9FusedCFuncDefNode.synthesize_defnodes..cSsg|]}t|jqSr/)rZ EncodedStringrfrr/r/r0r5@scSs g|]\}}tj|j|dqS))value)rZ StringNoder)r3rsigr/r/r0r5BscSsg|]}tjj|ddqS)T)Zbinding)rZPyCFunctionNodeZ from_defnoderr/r/r0r5DsTN) rrrrrZDictNodeZ from_pairsrrrZis_specialization)r)rZ signatureskeysvaluesZ pycfuncnoder/r/r0r7s z%FusedCFuncDefNode.synthesize_defnodescCsV|jrd|j_|j|||jD].}t|tr"|jjr"| |j |||q"dS)NT) rNZpymethdef_requiredrgenerate_function_definitionsr(rr r rHmark_posr)r)r*coderr/r/r0rMs  z/FusedCFuncDefNode.generate_function_definitionscCsT|jD]}|dur||q|jr<|j||j||jD]2}||jt|t j rj||qB| |qB|j r$|j ||d|j |j f||j |j ||j ||j ||j ||j ||j||j||j||j||jD]$}|dur*||||q*dS)Nz8((__pyx_FusedFunctionObject *) %s)->__signatures__ = %s;)rZgenerate_evaluation_coderNrrr(rrrrZExprNodegenerate_execution_coderrrr]Z put_giverefZgenerate_post_assignment_codeZ free_tempsrZgenerate_disposal_code)r)rrrr/r/r0rWsD                      z)FusedCFuncDefNode.generate_execution_codecCs|jD]}||qdSr)r(annotate)r)rrr/r/r0rs zFusedCFuncDefNode.annotate)(__name__ __module__ __qualname____doc__rrrrZ decoratorsrZ child_attrsrrrr:rBrErFrKrtr|r}r~rrrrrrrrrrMrrrrrr __classcell__r/r/r-r0r sH )V '(=;#2 ,r) __future__rr?rrrrrrr r r r ZNodesr rrrZUtilsrrr/r/r/r0s