class_docstr: Given a list of video files, computes all consecutive subvideos of size
  `clip_length_in_frames`, where the distance between each subvideo in the
  same video is defined by `frames_between_clips`.
  If `frame_rate` is specified, it will also resample all the videos to have
  the same frame rate, and the clips will refer to this frame rate.
  
  Creating this instance the first time is time-consuming, as it needs to
  decode all the videos in `video_paths`. It is recommended that you
  cache the results after instantiation of the class.
  
  Recreating the clips for different clip lengths is fast, and can be done
  with the `compute_clips` method.
  
  Args:
      video_paths (List[str]): paths to the video files
      clip_length_in_frames (int): size of a clip in number of frames
      frames_between_clips (int): step (in frames) between each clip
      frame_rate (int, optional): if specified, it will resample the video
          so that it has `frame_rate`, and then the clips will be defined
          on the resampled video
      num_workers (int): how many subprocesses to use for data loading.
          0 means that the data will be loaded in the main process. (default: 0)
      output_format (str): The format of the output video tensors. Can be either "THWC" (default) or "TCHW".
code: def compute_clips_for_video(
      video_pts: torch.Tensor,
      num_frames: int,
      step: int,
      fps: int,
      frame_rate: Optional[int] = None,
  ) -> Tuple[torch.Tensor, Union[List[slice], torch.Tensor]]:
      if fps is None:
          # if for some reason the video doesn't have fps (because doesn't have a video stream)
          # set the fps to 1. The value doesn't matter, because video_pts is empty anyway
          fps = 1
      if frame_rate is None:
          frame_rate = fps
      total_frames = len(video_pts) * (float(frame_rate) / fps)
      _idxs = VideoClips._resample_video_idx(
          int(math.floor(total_frames)), fps, frame_rate
      )
      video_pts = video_pts[_idxs]
      clips = unfold(video_pts, num_frames, step)
      if not clips.numel():
          warnings.warn(
              "There aren't enough frames in the current video to get a clip for the given clip length and "
              "frames between clips. The video (and potentially others) will be skipped."
          )
      idxs: Union[List[slice], torch.Tensor]
      if isinstance(_idxs, slice):
          idxs = [_idxs] * len(clips)
      else:
          idxs = unfold(_idxs, num_frames, step)
      return clips, idxs
  
imports: import bisect
  import math
  import warnings
  from fractions import Fraction
  from typing import Any, Callable, cast, Dict, List, Optional, Tuple, TypeVar, Union
  import torch
  from torchvision.io import _probe_video_from_file, _read_video_from_file, read_video, read_video_timestamps
  from .utils import tqdm
label_desc: Use image node_id 6 for calling the VideoClips obj's underlying member method code with example usage: obj.compute_clips_for_video(video_pts, num_frames, step, fps, frame_rate) and returns: clips,  idxs