code: def _make_internal_batchify_functions(handle):
      """Create an io iterator by handle."""
      name = ctypes.c_char_p()
      desc = ctypes.c_char_p()
      num_args = mx_uint()
      arg_names = ctypes.POINTER(ctypes.c_char_p)()
      arg_types = ctypes.POINTER(ctypes.c_char_p)()
      arg_descs = ctypes.POINTER(ctypes.c_char_p)()
  
      check_call(
          _LIB.MXBatchifyFunctionGetFunctionInfo(
              handle,
              ctypes.byref(name),
              ctypes.byref(desc),
              ctypes.byref(num_args),
              ctypes.byref(arg_names),
              ctypes.byref(arg_types),
              ctypes.byref(arg_descs),
          )
      )
      bf_name = py_str(name.value)
  
      narg = int(num_args.value)
      param_str = _build_param_doc(
          [py_str(arg_names[i]) for i in range(narg)],
          [py_str(arg_types[i]) for i in range(narg)],
          [py_str(arg_descs[i]) for i in range(narg)],
      )
  
      doc_str = (
          f"{desc.value}\n\n"
          + f"{param_str}\n"
          + "Returns\n"
          + "-------\n"
          + "MXBatchifyFunction\n"
          + "    The result batchify function."
      )
  
      def creator(*args, **kwargs):
          """Create an iterator.
          The parameters listed below can be passed in as keyword arguments.
  
          Parameters
          ----------
          name : string, required.
              Name of the resulting batchify function.
  
          Returns
          -------
          batchify_func: BatchifyFunction
              The resulting batchify function.
          """
          param_keys = []
          param_vals = []
  
          for k, val in kwargs.items():
              # convert ndarray to handle
              if hasattr(val, "handle"):
                  val = val.handle.value
              if isinstance(val, (tuple, list)):
                  val = [
                      vv.handle.value if hasattr(vv, "handle") else vv
                      for vv in val
                  ]
              param_keys.append(k)
              param_vals.append(str(val))
          # create atomic symbol
          param_keys = c_str_array(param_keys)
          param_vals = c_str_array(param_vals)
          batchify_fn_handle = BatchifyFunctionhandle()
          check_call(
              _LIB.MXBatchifyFunctionCreateFunction(
                  handle,
                  mx_uint(len(param_keys)),
                  param_keys,
                  param_vals,
                  ctypes.byref(batchify_fn_handle),
              )
          )
  
          if len(args):
              raise TypeError(
                  f"{bf_name} can only accept keyword arguments"
              )
  
          return MXBatchifyFunction(
              batchify_fn_handle, creator_name=bf_name, **kwargs
          )
  
      creator.__name__ = bf_name
      creator.__doc__ = doc_str
      return creator
  
imports: import sys
  import ctypes
  from .dataset import Dataset
  from .sampler import Sampler
  from ...base import _LIB
  from ...base import c_str_array, mx_uint, py_str
  from ...base import DatasetHandle, NDArrayHandle, BatchifyFunctionhandle
  from ...base import check_call, build_param_doc
  from ...ndarray import NDArray
  from ...ndarray import _ndarray_cls
  from ...numpy.multiarray import _np_ndarray_cls
  from ...util import is_np_array, default_array
  from ...io import io
label_desc: Use image node_id 3 for calling a global function with example usage: _make_internal_batchify_functions(handle) and returns: creator, MXBatchifyFunction