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_frame_pts(self) -> None:
      self.video_pts = (
          []
      )  # len = num_videos. Each entry is a tensor of shape (num_frames_in_video,)
      self.video_fps: List[int] = []  # len = num_videos
  
      # strategy: use a DataLoader to parallelize read_video_timestamps
      # so need to create a dummy dataset first
      import torch.utils.data
  
      dl: torch.utils.data.DataLoader = torch.utils.data.DataLoader(
          _VideoTimestampsDataset(self.video_paths),  # type: ignore[arg-type]
          batch_size=16,
          num_workers=self.num_workers,
          collate_fn=_collate_fn,
      )
  
      with tqdm(total=len(dl)) as pbar:
          for batch in dl:
              pbar.update(1)
              batch_pts, batch_fps = list(zip(*batch))
              # we need to specify dtype=torch.long because for empty list,
              # torch.as_tensor will use torch.float as default dtype. This
              # happens when decoding fails and no pts is returned in the list.
              batch_pts = [
                  torch.as_tensor(pts, dtype=torch.long)
                  for pts in batch_pts
              ]
              self.video_pts.extend(batch_pts)
              self.video_fps.extend(batch_fps)
  
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 2 for calling the VideoClips obj's underlying member method code with example usage: obj._compute_frame_pts() without return types