class_docstr: This class implements the :class:`torch_geometric.data.FeatureStore`
  interface to act as a local feature store for distributed training.
code: def from_partition(cls, root: str, pid: int) -> "LocalFeatureStore":
      with open(osp.join(root, "META.json"), "r") as f:
          meta = json.load(f)
  
      part_dir = osp.join(root, f"part_{pid}")
      assert osp.exists(part_dir)
  
      node_feats: Optional[Dict[str, Any]] = None
      if osp.exists(osp.join(part_dir, "node_feats.pt")):
          node_feats = torch.load(osp.join(part_dir, "node_feats.pt"))
  
      edge_feats: Optional[Dict[str, Any]] = None
      if osp.exists(osp.join(part_dir, "edge_feats.pt")):
          edge_feats = torch.load(osp.join(part_dir, "edge_feats.pt"))
  
      feat_store = cls()
  
      if not meta["is_hetero"] and node_feats is not None:
          feat_store.put_global_id(
              node_feats["global_id"], group_name=None
          )
          for key, value in node_feats["feats"].items():
              feat_store.put_tensor(
                  value, group_name=None, attr_name=key
              )
  
      if not meta["is_hetero"] and edge_feats is not None:
          feat_store.put_global_id(
              edge_feats["global_id"], group_name=(None, None)
          )
          for key, value in edge_feats["feats"].items():
              feat_store.put_tensor(
                  value, group_name=(None, None), attr_name=key
              )
  
      if meta["is_hetero"] and node_feats is not None:
          for node_type, node_feat in node_feats.items():
              feat_store.put_global_id(
                  node_feat["global_id"], group_name=node_type
              )
              for key, value in node_feat["feats"].items():
                  feat_store.put_tensor(
                      value, group_name=node_type, attr_name=key
                  )
  
      if meta["is_hetero"] and edge_feats is not None:
          for edge_type, edge_feat in edge_feats.items():
              feat_store.put_global_id(
                  edge_feat["global_id"], group_name=edge_type
              )
              for key, value in edge_feat["feats"].items():
                  feat_store.put_tensor(
                      value, group_name=edge_type, attr_name=key
                  )
  
      return feat_store
  
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 21 for calling the LocalFeatureStore obj's underlying member method code with example usage: obj.from_partition(cls, root, pid) and returns: feat_store