code: def call_message_passing_module(
      self, node: Node, target: Any, name: str
  ):
      # Add calls to edge type-wise `MessagePassing` modules and aggregate
      # the outputs to node type-wise embeddings afterwards.
  
      module = get_submodule(self.module, target)
      check_add_self_loops(module, self.metadata[1])
  
      # Group edge-wise keys per destination:
      key_name, keys_per_dst = {}, defaultdict(list)
      for key in self.metadata[1]:
          keys_per_dst[key[-1]].append(key)
          key_name[
              key
          ] = f"{name}__{key[-1]}{len(keys_per_dst[key[-1]])}"
  
      for dst, keys in dict(keys_per_dst).items():
          # In case there is only a single edge-wise connection, there is no
          # need for any destination-wise aggregation, and we can already set
          # the intermediate variable name to the final output name.
          if len(keys) == 1:
              key_name[keys[0]] = f"{name}__{dst}"
              del keys_per_dst[dst]
  
      self.graph.inserting_after(node)
      for key in self.metadata[1]:
          args, kwargs = self.map_args_kwargs(node, key)
          out = self.graph.create_node(
              "call_module",
              target=f"{target}.{key2str(key)}",
              args=args,
              kwargs=kwargs,
              name=key_name[key],
          )
          self.graph.inserting_after(out)
  
      # Perform destination-wise aggregation.
      # Here, we aggregate in pairs, popping the first two elements of
      # `keys_per_dst` and append the result to the list.
      for dst, keys in keys_per_dst.items():
          queue = deque([key_name[key] for key in keys])
          i = 1
          while len(queue) >= 2:
              key1, key2 = queue.popleft(), queue.popleft()
              args = (self.find_by_name(key1), self.find_by_name(key2))
  
              new_name = f"{name}__{dst}"
              if self.aggr == "mean" or len(queue) > 0:
                  new_name = f"{new_name}_{i}"
  
              out = self.graph.create_node(
                  "call_function",
                  target=self.aggrs[self.aggr],
                  args=args,
                  name=new_name,
              )
              self.graph.inserting_after(out)
              queue.append(new_name)
              i += 1
  
          if self.aggr == "mean":
              key = queue.popleft()
              out = self.graph.create_node(
                  "call_function",
                  target=torch.div,
                  args=(self.find_by_name(key), len(keys_per_dst[dst])),
                  name=f"{name}__{dst}",
              )
              self.graph.inserting_after(out)
  
imports: import copy
  import warnings
  from collections import defaultdict, deque
  from typing import Any, Dict, Optional, Tuple, Union
  import torch
  from torch.nn import Module
  from torch_geometric.nn.dense.linear import is_uninitialized_parameter
  from torch_geometric.nn.fx import Transformer, get_submodule
  from torch_geometric.typing import EdgeType, Metadata, NodeType
  from torch_geometric.utils.hetero import check_add_self_loops, get_unused_node_types
label_desc: Use image node_id 5 for calling the ToHeteroTransformer obj's underlying member method code with example usage: obj.call_message_passing_module(node, target, name) without return types