code: def test_cugraph_loader_from_disk_subset_csr():
      m = [2, 9, 99, 82, 11, 13]
      n = torch.arange(1, 1 + len(m), dtype=torch.int32)
      x = torch.zeros(256, dtype=torch.int32)
      x[torch.tensor(m, dtype=torch.int32)] = n
      F = FeatureStore()
      F.add_data(x, "t0", "x")
  
      G = {("t0", "knows", "t0"): 9080}
      N = {"t0": 256}
  
      cugraph_store = CuGraphStore(F, G, N)
  
      bogus_samples = cudf.DataFrame(
          {
              "major_offsets": [0, 3, 5, 7, 8, None, None, None],
              "minors": [1, 2, 3, 0, 3, 4, 5, 1],
              "edge_type": cudf.Series(
                  [0, 0, 0, 0, 0, 0, 0, 0], dtype="int32"
              ),
              "edge_id": [5, 10, 15, 20, 25, 30, 35, 40],
              "label_hop_offsets": cudf.Series(
                  [0, 1, 4, None, None, None, None, None], dtype="int32"
              ),
              "renumber_map_offsets": cudf.Series(
                  [0, 6], dtype="int32"
              ),
          }
      )
      map = cudf.Series(m, name="map")
      bogus_samples["map"] = map
  
      tempdir = tempfile.TemporaryDirectory()
      for s in range(256):
          # offset the offsets
          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],
      )
  
      num_samples = 0
      for sample in loader:
          num_samples += 1
          assert sample["t0"]["num_nodes"] == 6
  
          assert sample["t0"]["x"].tolist() == [1, 2, 3, 4, 5, 6]
  
          edge_index = sample[("t0", "knows", "t0")]["adj_t"]
          assert edge_index.size(0) == 4
          assert edge_index.size(1) == 6
  
          colptr, row, _ = edge_index.csr()
  
          assert (
              colptr.tolist()
              == bogus_samples.major_offsets.dropna().values_host.tolist()
          )
          assert (
              row.tolist()
              == bogus_samples.minors.dropna().values_host.tolist()
          )
  
          assert sample["t0"]["num_sampled_nodes"].tolist() == [1, 3, 2]
          assert sample["t0", "knows", "t0"][
              "num_sampled_edges"
          ].tolist() == [3, 5]
  
      assert num_samples == 100
  
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 5 for calling a global function with example usage: test_cugraph_loader_from_disk_subset_csr() without return types