class_docstr: This class implements the :class:`torch_geometric.data.FeatureStore`
  interface to act as a local feature store for distributed training.
docstr: Fetch the remote features with the remote node/edge IDs.
docstr_tok: ["Fetch","the","remote","features","with","the","remote","node\/edge","IDs","."]
code: def _remote_lookup_features(
      self,
      index: Tensor,
      is_node_feat: bool = True,
      input_type: Optional[Union[NodeType, EdgeType]] = None,
  ) -> torch.futures.Future:
      r"""Fetch the remote features with the remote node/edge IDs."""
      pb = self.node_feat_pb if is_node_feat else self.edge_feat_pb
  
      input_order = torch.arange(index.size(0), dtype=torch.long)
      if self.meta["is_hetero"]:
          partition_ids = pb[input_type][index]
      else:
          partition_ids = pb[index]
  
      futs, indexes = [], []
      for pidx in range(0, self.num_partitions):
          if pidx == self.partition_idx:
              continue
          remote_mask = partition_ids == pidx
          remote_ids = index[remote_mask]
          if remote_ids.shape[0] > 0:
              to_worker = self.rpc_router.get_to_worker(pidx)
              futs.append(
                  rpc_async(
                      to_worker,
                      self.rpc_call_id,
                      args=(remote_ids.cpu(), is_node_feat, input_type),
                  )
              )
              indexes.append(
                  torch.masked_select(input_order, remote_mask)
              )
      collect_fut = torch.futures.collect_all(futs)
      res_fut = torch.futures.Future()
  
      def when_finish(*_):
          try:
              fut_list = collect_fut.wait()
              result = []
              for i, fut in enumerate(fut_list):
                  result.append((fut.wait(), indexes[i]))
          except Exception as e:
              res_fut.set_exception(e)
          else:
              res_fut.set_result(result)
  
      collect_fut.add_done_callback(when_finish)
      return res_fut
  
imports: import copy
  import json
  import os.path
  from dataclasses import dataclass
  from typing import Any, Dict, List, Optional, Tuple, Union
  import torch
  from torch import Tensor
  from torch_geometric.data import FeatureStore, TensorAttr
  from torch_geometric.data.feature_store import _FieldStatus
  from torch_geometric.distributed.rpc import RPCCallBase, RPCRouter, rpc_async, rpc_register
  from torch_geometric.typing import EdgeType, NodeOrEdgeType, NodeType
label_desc: Use image node_id 17 for calling the LocalFeatureStore obj's underlying member method code with example usage: obj._remote_lookup_features(index, is_node_feat, input_type) and returns: res_fut