class_docstr: `Generic Kinetics <https://www.deepmind.com/open-source/kinetics>`_
  dataset.
  
  Kinetics-400/600/700 are action recognition video datasets.
  This dataset consider every video as a collection of video clips of fixed size, specified
  by ``frames_per_clip``, where the step in frames between each clip is given by
  ``step_between_clips``.
  
  To give an example, for 2 videos with 10 and 15 frames respectively, if ``frames_per_clip=5``
  and ``step_between_clips=5``, the dataset size will be (2 + 3) = 5, where the first two
  elements will come from video 1, and the next three elements from video 2.
  Note that we drop clips which do not have exactly ``frames_per_clip`` elements, so not all
  frames in a video might be present.
  
  Args:
      root (string): Root directory of the Kinetics Dataset.
          Directory should be structured as follows:
          .. code::
  
              root/
              ├── split
              │   ├──  class1
              │   │   ├──  vid1.mp4
              │   │   ├──  vid2.mp4
              │   │   ├──  vid3.mp4
              │   │   ├──  ...
              │   ├──  class2
              │   │   ├──   vidx.mp4
              │   │    └── ...
  
          Note: split is appended automatically using the split argument.
      frames_per_clip (int): number of frames in a clip
      num_classes (int): select between Kinetics-400 (default), Kinetics-600, and Kinetics-700
      split (str): split of the dataset to consider; supports ``"train"`` (default) ``"val"`` ``"test"``
      frame_rate (float): If omitted, interpolate different frame rate for each clip.
      step_between_clips (int): number of frames between each clip
      transform (callable, optional): A function/transform that takes in a TxHxWxC video
          and returns a transformed version.
      download (bool): Download the official version of the dataset to root folder.
      num_workers (int): Use multiple workers for VideoClips creation
      num_download_workers (int): Use multiprocessing in order to speed up download.
      output_format (str, optional): The format of the output video tensors (before transforms).
          Can be either "THWC" or "TCHW" (default).
          Note that in most other utils and datasets, the default is actually "THWC".
  
  Returns:
      tuple: A 3-tuple with the following entries:
  
          - video (Tensor[T, C, H, W] or Tensor[T, H, W, C]): the `T` video frames in torch.uint8 tensor
          - audio(Tensor[K, L]): the audio frames, where `K` is the number of channels
            and `L` is the number of points in torch.float tensor
          - label (int): class of the video clip
  
  Raises:
      RuntimeError: If ``download is True`` and the video archives are already extracted.
docstr: Downloads all the videos to the _root_ folder in the expected format.
docstr_tok: ["Downloads","all","the","videos","to","the","_root_","folder","in","the","expected","format","."]
code: def download_and_process_videos(self) -> None:
      """Downloads all the videos to the _root_ folder in the expected format."""
      tic = time.time()
      self._download_videos()
      toc = time.time()
      print("Elapsed time for downloading in mins ", (toc - tic) / 60)
      self._make_ds_structure()
      toc2 = time.time()
      print("Elapsed time for processing in mins ", (toc2 - toc) / 60)
      print("Elapsed time overall in mins ", (toc2 - tic) / 60)
  
imports: import csv
  import os
  import time
  import urllib
  from functools import partial
  from multiprocessing import Pool
  from os import path
  from typing import Any, Callable, Dict, Optional, Tuple
  from torch import Tensor
  from .folder import find_classes, make_dataset
  from .utils import check_integrity, download_and_extract_archive, download_url, verify_str_arg
  from .video_utils import VideoClips
  from .vision import VisionDataset
label_desc: Use image node_id 2 for calling the Kinetics obj's underlying member method code with example usage: obj.download_and_process_videos() without return types