class_docstr: Generate code for a fused-type special function that can be
  cimported in Cython.
code: def _generate_from_return_and_no_outargs(self):
      tab = " " * 4
      specs, body = [], []
      for signum, sig in enumerate(self.signatures):
          (
              func_name,
              incodes,
              outcodes,
              retcode,
              intypes,
              outtypes,
              rettype,
              c,
              lines,
              sp,
          ) = self._get_common(signum, sig)
          body.extend(lines)
  
          # Generate the call to the specialized function
          callvars = self._get_incallvars(intypes, c)
          call = "{}({})".format(func_name, ", ".join(callvars))
          if c and rettype == "double complex":
              call = double_complex_from_npy_cdouble(call)
          line = sp + f"return {call}"
          body.append(line)
          sig = f"{incodes}->{retcode}"
          specs.append(sig)
  
      if len(specs) > 1:
          # Return nan for signatures without a specialization
          body.append(tab + "else:")
          outtype, outcodes = self.outtypes[0]
          last = len(outcodes) - 1
          if len(outcodes) == 1:
              line = f"return {NAN_VALUE[outcodes]}"
              body.append(2 * tab + line)
          else:
              for n, code in enumerate(outcodes):
                  if n == 0:
                      adverb = "if"
                  elif n == last:
                      adverb = "else"
                  else:
                      adverb = "elif"
                  cond = self._get_conditional(
                      self.outtypes, code, adverb
                  )
                  body.append(2 * tab + cond)
                  line = f"return {NAN_VALUE[code]}"
                  body.append(3 * tab + line)
  
      # Generate the head of the function
      callvars, head = [], []
      for n, (intype, _) in enumerate(self.intypes):
          callvars.append(f"{intype} {self.invars[n]}")
      (outtype, _) = self.outtypes[0]
      dec = f'cpdef {outtype} {self.name}({", ".join(callvars)}) noexcept nogil'
      head.append(dec + ":")
      head.append(tab + f'"""{self.doc}"""')
  
      src = "\n".join(head + body)
      return dec, src, specs
  
imports: import itertools
  import json
  import os
  from stat import ST_MTIME
  import argparse
  import re
  import textwrap
  import numpy
label_desc: Use image node_id 12 for calling the FusedFunc obj's underlying member method code with example usage: obj._generate_from_return_and_no_outargs() and returns: dec,  src,  specs