code: def test_cugraph_loader_e2e_coo():
      m = [2, 9, 99, 82, 9, 3, 18, 1, 12]
      x = torch.randint(3000, (256, 256)).to(torch.float32)
      F = FeatureStore()
      F.add_data(x, "t0", "x")
  
      G = {("t0", "knows", "t0"): 9999}
      N = {"t0": 256}
  
      cugraph_store = CuGraphStore(F, G, N, order="CSR")
  
      bogus_samples = cudf.DataFrame(
          {
              "majors": [0, 1, 2, 3, 4, 5, 6, 6],
              "minors": [5, 4, 3, 2, 2, 6, 5, 2],
              "edge_type": cudf.Series(
                  [0, 0, 0, 0, 0, 0, 0, 0], dtype="int32"
              ),
              "edge_id": [5, 10, 15, 20, 25, 30, 35, 40],
              "hop_id": cudf.Series(
                  [0, 0, 0, 1, 1, 1, 2, 2], dtype="int32"
              ),
          }
      )
      map = cudf.Series(m, name="map")
      bogus_samples = bogus_samples.join(map, how="outer").sort_index()
  
      tempdir = tempfile.TemporaryDirectory()
      for s in range(256):
          bogus_samples["batch_id"] = cupy.int32(s)
          bogus_samples.to_parquet(
              os.path.join(tempdir.name, f"batch={s}-{s}.parquet")
          )
  
      loader = BulkSampleLoader(
          feature_store=cugraph_store,
          graph_store=cugraph_store,
          directory=tempdir,
          input_files=list(os.listdir(tempdir.name))[100:200],
      )
  
      convs = [
          torch_geometric.nn.SAGEConv(256, 64, aggr="mean").cuda(),
          torch_geometric.nn.SAGEConv(64, 8, aggr="mean").cuda(),
          torch_geometric.nn.SAGEConv(8, 1, aggr="mean").cuda(),
      ]
  
      trim = trim_to_layer.TrimToLayer()
      relu = torch.nn.functional.relu
      dropout = torch.nn.functional.dropout
  
      for hetero_data in loader:
          ei = hetero_data["t0", "knows", "t0"]["edge_index"]
          x = hetero_data["t0"]["x"].cuda()
          num_sampled_nodes = hetero_data["t0"]["num_sampled_nodes"]
          num_sampled_edges = hetero_data["t0", "knows", "t0"][
              "num_sampled_edges"
          ]
  
          for i in range(len(convs)):
              x, ei, _ = trim(
                  i, num_sampled_nodes, num_sampled_edges, x, ei, None
              )
  
              s = x.shape[0]
  
              x = convs[i](x, ei, size=(s, s))
              x = relu(x)
              x = dropout(x, p=0.5)
  
          x = x.narrow(
              dim=0, start=0, length=x.shape[0] - num_sampled_nodes[1]
          )
  
          assert list(x.shape) == [3, 1]
  
imports: import pytest
  import tempfile
  import os
  import cudf
  import cupy
  import numpy
  from cugraph_pyg.loader import CuGraphNeighborLoader
  from cugraph_pyg.loader import BulkSampleLoader
  from cugraph_pyg.data import CuGraphStore
  from cugraph_pyg.nn import SAGEConv
  from cugraph.gnn import FeatureStore
  from cugraph.utilities.utils import import_optional, MissingModule
  from typing import Dict, Tuple
label_desc: Use image node_id 6 for calling a global function with example usage: test_cugraph_loader_e2e_coo() without return types