code: def test_uniform_neighbor_sample_edge_properties(
      dask_client, return_offsets
  ):
      n_workers = len(dask_client.scheduler_info()["workers"])
      if n_workers <= 1:
          pytest.skip("Test only valid for MG environments")
      edgelist_df = dask_cudf.from_cudf(
          cudf.DataFrame(
              {
                  "src": [0, 1, 2, 3, 4, 3, 4, 2, 0, 1, 0, 2],
                  "dst": [1, 2, 4, 2, 3, 4, 1, 1, 2, 3, 4, 4],
                  "eid": cudf.Series(
                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
                      dtype="int64",
                  ),
                  "etp": cudf.Series(
                      [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 0],
                      dtype="int32",
                  ),
                  "w": [
                      0.0,
                      0.1,
                      0.2,
                      3,
                      0.4,
                      0.5,
                      0.6,
                      0.7,
                      0.8,
                      0.9,
                      0.10,
                      0.11,
                  ],
              }
          ),
          npartitions=2,
      )
  
      G = cugraph.MultiGraph(directed=True)
      G.from_dask_cudf_edgelist(
          edgelist_df,
          source="src",
          destination="dst",
          edge_attr=["w", "eid", "etp"],
      )
  
      sampling_results = cugraph.dask.uniform_neighbor_sample(
          G,
          start_list=cudf.DataFrame(
              {
                  "start": cudf.Series([0, 4], dtype="int64"),
                  "batch": cudf.Series([0, 1], dtype="int32"),
              }
          ),
          fanout_vals=[-1, -1],
          with_replacement=False,
          with_edge_properties=True,
          with_batch_ids=True,
          keep_batches_together=True,
          min_batch_id=0,
          max_batch_id=1,
          return_offsets=return_offsets,
      )
  
      if return_offsets:
          sampling_results, sampling_offsets = sampling_results
  
          batches_found = {0: 0, 1: 0}
          for i in range(n_workers):
              dfp = sampling_results.get_partition(i).compute()
              if len(dfp) > 0:
                  offsets_p = sampling_offsets.get_partition(
                      i
                  ).compute()
                  print(offsets_p)
                  assert len(offsets_p) > 0
  
                  if offsets_p.batch_id.iloc[0] == 1:
                      batches_found[1] += 1
  
                      assert offsets_p.batch_id.dropna().values_host.tolist() == [
                          1
                      ]
                      assert offsets_p.offsets.dropna().values_host.tolist() == [
                          0,
                          len(dfp),
                      ]
  
                      assert sorted(
                          dfp.sources.values_host.tolist()
                      ) == ([1, 1, 3, 3, 4, 4])
                      assert sorted(
                          dfp.destinations.values_host.tolist()
                      ) == ([1, 2, 2, 3, 3, 4])
                  elif offsets_p.batch_id.iloc[0] == 0:
                      batches_found[0] += 1
  
                      assert offsets_p.batch_id.dropna().values_host.tolist() == [
                          0
                      ]
                      assert offsets_p.offsets.dropna().values_host.tolist() == [
                          0,
                          len(dfp),
                      ]
  
                      assert sorted(
                          dfp.sources.values_host.tolist()
                      ) == ([0, 0, 0, 1, 1, 2, 2, 2, 4, 4])
                      assert sorted(
                          dfp.destinations.values_host.tolist()
                      ) == ([1, 1, 1, 2, 2, 3, 3, 4, 4, 4])
  
      mdf = cudf.merge(
          sampling_results.compute(),
          edgelist_df.compute(),
          left_on="edge_id",
          right_on="eid",
      )
      assert (mdf.w == mdf.weight).all()
      assert (mdf.etp == mdf.edge_type).all()
      assert (mdf.src == mdf.sources).all()
      assert (mdf.dst == mdf.destinations).all()
  
      assert sorted(
          sampling_results.compute()["hop_id"].values_host.tolist()
      ) == [
          0,
          0,
          0,
          0,
          0,
          1,
          1,
          1,
          1,
          1,
          1,
          1,
          1,
          1,
          1,
          1,
      ]
  
imports: import gc
  import random
  import os
  import pytest
  import pandas
  import cupy
  import cudf
  import cugraph
  import dask_cudf
  import cugraph.dask
  from cugraph.testing import UNDIRECTED_DATASETS
  from cugraph.dask import uniform_neighbor_sample
  from cugraph.dask.common.mg_utils import is_single_gpu
  from cugraph.datasets import email_Eu_core, small_tree
  from pylibcugraph.testing.utils import gen_fixture_params_product
label_desc: Use image node_id 7 for calling a global function with example usage: test_uniform_neighbor_sample_edge_properties(dask_client, return_offsets) without return types