class_docstr: 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[:])
class_docstr_tok: ["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","[",":","]",")"]
docstr: 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.
docstr_tok: ["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","."]
code: def _buffer_checks(
      self, buffer_types, pythran_types, pyx_code, decl_code, env
  ):
      """
      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.
      """
      # The first thing to find a match in this loop breaks out of the loop
      pyx_code.put_chunk(
          """
                  """
          + (
              "arg_is_pythran_compatible = False"
              if pythran_types
              else ""
          )
          + """
                  if ndarray is not None:
                      if isinstance(arg, ndarray):
                          dtype = arg.dtype
                          """
          + (
              "arg_is_pythran_compatible = True"
              if pythran_types
              else ""
          )
          + """
                      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'
              """
      )
      pyx_code.indent(2)
      if pythran_types:
          pyx_code.put_chunk(
              """
                          # 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 (<Py_ssize_t>strides[i]) != cur_stride:
                                      arg_is_pythran_compatible = False
                                      break
                                  cur_stride *= <Py_ssize_t> shape[i]
                              else:
                                  arg_is_pythran_compatible = not (arg.flags.f_contiguous and (<Py_ssize_t>arg.ndim) > 1)
                  """
          )
      pyx_code.named_insertion_point("numpy_dtype_checks")
      self._buffer_check_numpy_dtype(
          pyx_code, buffer_types, pythran_types
      )
      pyx_code.dedent(2)
  
      for specialized_type in buffer_types:
          self._buffer_parse_format_string_check(
              pyx_code, decl_code, specialized_type, env
          )
  
imports: from __future__ import absolute_import
  import copy
  from .None import ExprNodes, PyrexTypes, MemoryView, ParseTreeTransforms, StringEncoding, Errors
  from .ExprNodes import CloneNode, ProxyNode, TupleNode
  from .Nodes import FuncDefNode, CFuncDefNode, StatListNode, DefNode
  from ..Utils import OrderedSet
label_desc: Use image node_id 16 for calling the FusedCFuncDefNode obj's underlying member method code with example usage: obj._buffer_checks(buffer_types, pythran_types, pyx_code, decl_code, env) without return types