code: def gen_do(self, method="do"):
      out = """
  // do {shortname}
  static PyObject*
  Pyaubio_{shortname}_{method}  (Py_{shortname} * self, PyObject * args)
  {{""".format(
          method=method, **self.__dict__
      )
      input_params = self.do_inputs
      output_params = self.do_outputs
      # print input_params
      # print output_params
      out += """
      PyObject *outputs;"""
      for input_param in input_params:
          out += """
      PyObject *py_{0};""".format(
              input_param["name"]
          )
      refs = ", ".join(["&py_%s" % p["name"] for p in input_params])
      pyparamtypes = "".join(
          [pyargparse_chars[p["type"]] for p in input_params]
      )
      out += """
      if (!PyArg_ParseTuple (args, "{pyparamtypes}", {refs})) {{
          return NULL;
      }}""".format(
          refs=refs, pyparamtypes=pyparamtypes, **self.__dict__
      )
      for input_param in input_params:
          out += """
  
      if (!{pytoaubio}(py_{0[name]}, &(self->{0[name]}))) {{
          return NULL;
      }}""".format(
              input_param, pytoaubio=pytoaubio_fn[input_param["type"]]
          )
      if self.shortname in objinputsize:
          out += """
  
      if (self->{0[name]}.length != {expected_size}) {{
          PyErr_Format (PyExc_ValueError,
              "input size of {shortname} should be %d, not %d",
              {expected_size}, self->{0[name]}.length);
          return NULL;
      }}""".format(
              input_param,
              expected_size=objinputsize[self.shortname],
              **self.__dict__,
          )
      else:
          out += """
  
      // TODO: check input sizes"""
      for output_param in output_params:
          out += """
  
      Py_INCREF(self->{0[name]});
      if (!{pytoaubio}(self->{0[name]}, &(self->c_{0[name]}))) {{
          return NULL;
      }}""".format(
              output_param, pytoaubio=pytoaubio_fn[output_param["type"]]
          )
      do_fn = get_name(self.do_proto)
      inputs = ", ".join(
          ["&(self->" + p["name"] + ")" for p in input_params]
      )
      c_outputs = ", ".join(
          ["&(self->c_%s)" % p["name"] for p in self.do_outputs]
      )
      outputs = ", ".join(
          ["self->%s" % p["name"] for p in self.do_outputs]
      )
      out += """
  
      {do_fn}(self->o, {inputs}, {c_outputs});
  """.format(
          do_fn=do_fn,
          inputs=inputs,
          c_outputs=c_outputs,
      )
      if len(self.do_outputs) > 1:
          out += """
      outputs = PyTuple_New({:d});""".format(
              len(self.do_outputs)
          )
          for i, p in enumerate(self.do_outputs):
              out += """
      PyTuple_SetItem( outputs, {i}, self->{p[name]});""".format(
                  i=i, p=p
              )
      else:
          out += """
      outputs = self->{p[name]};""".format(
              p=self.do_outputs[0]
          )
      out += """
  
      return outputs;
  }}
  """.format(
          outputs=outputs,
      )
      return out
  
label_desc: Use image node_id 13 for calling the MappedObject obj's underlying member method code with example usage: obj.gen_do(method) and returns: out