code: def test_sampling_with_non_divisible_processes_by_clips(
      self, decoder
  ):
      # Make one video with 15 frames and one with 10 frames, producing 3 clips and 2
      # clips respectively.
      num_frames = 10
      fps = 5
      with temp_encoded_video(
          num_frames=int(num_frames * 1.5), fps=fps
      ) as (
          video_file_name_1,
          data_1,
      ):
          with temp_encoded_video(num_frames=num_frames, fps=fps) as (
              video_file_name_2,
              data_2,
          ):
              with tempfile.NamedTemporaryFile(
                  delete=False, suffix=".txt"
              ) as f:
                  f.write(f"{video_file_name_1} 0\n".encode())
                  f.write(f"{video_file_name_2} 1\n".encode())
  
              total_duration = num_frames / fps
              half_duration = total_duration / 2
              clip_sampler = make_clip_sampler("uniform", half_duration)
              labeled_video_paths = LabeledVideoPaths.from_path(f.name)
              dataset = LabeledVideoDataset(
                  labeled_video_paths,
                  clip_sampler=clip_sampler,
                  video_sampler=SequentialSampler,
                  decode_audio=False,
                  decoder=decoder,
              )
  
              half_frames = num_frames // 2
              expected = {
                  (0, data_1[:, half_frames * 2 :]),  # 1/3 clip
                  (
                      0,
                      data_1[:, half_frames : half_frames * 2],
                  ),  # 2/3 clip
                  (0, data_1[:, :half_frames]),  # 3/3/ clip
                  (1, data_2[:, :half_frames]),  # First half
                  (1, data_2[:, half_frames:]),  # Second half
              }
  
              test_dataloader = DataLoader(
                  dataset, batch_size=None, num_workers=2
              )
              actual = [
                  (sample["label"], sample["video"])
                  for sample in test_dataloader
              ]
              assert_unordered_list_compare_true(self, expected, actual)
  
imports: import collections
  import contextlib
  import itertools
  import math
  import multiprocessing
  import os
  import pathlib
  import tempfile
  import unittest
  import unittest.mock
  from fractions import Fraction
  from typing import List, Tuple
  from unittest.mock import Mock, patch
  import av
  import torch
  import torch.distributed
  from parameterized import parameterized
  from pytorchvideo.data import Hmdb51
  from pytorchvideo.data.clip_sampling import make_clip_sampler
  from pytorchvideo.data.labeled_video_dataset import labeled_video_dataset, LabeledVideoDataset
  from pytorchvideo.data.labeled_video_paths import LabeledVideoPaths
  from pytorchvideo.data.utils import MultiProcessSampler, thwc_to_cthw
  from torch.multiprocessing import Process
  from torch.utils.data import DataLoader, DistributedSampler, RandomSampler, SequentialSampler, TensorDataset
  from utils import create_dummy_video_frames, temp_encoded_video, temp_frame_video_dataset
label_desc: Use image node_id 15 for calling the TestLabeledVideoDataset obj's underlying member method code with example usage: obj.test_sampling_with_non_divisible_processes_by_clips(decoder) without return types