def METHOD_NAME(self):
    """
    This takes a zipped set of videos, uses https://pypi.org/project/videohash/ and https://ffmpeg.org/ to collect
    frames from the videos at intervals and create image collages to hashes for comparison of videos.
    """
    # Check processor able to run
    if self.source_dataset.num_rows == 0:
        self.dataset.update_status("No videos from which to extract frames.", is_final=True)
        self.dataset.finish(0)
        return
    # Collect parameters
    frame_size = self.parameters.get("frame_size", "no_modify")
    # unpack source videos to get frames from
    video_dataset = self.source_dataset.nearest("video-downloader*")
    if not video_dataset:
        self.log.error(
            f"Trying to extract video data from non-video dataset {video_dataset.key} (type '{video_dataset.type}')")
        return self.dataset.finish_with_error("Video data missing for scene metadata. Cannot extract frames.")
    # map scenes to filenames
    scenes = {}
    for scene in self.source_dataset.iterate_items(self):
        filename = "_scene_".join(scene["id"].split("_scene_")[:-1])
        if filename not in scenes:
            scenes[filename] = []
        scenes[filename].append(scene)
    # two separate staging areas:
    # one to store the videos we're reading from
    # one to store the frames we're capturing
    video_staging_area = video_dataset.get_staging_area()
    staging_area = self.dataset.get_staging_area()
    # now go through videos and get the relevant frames
    errors = 0
    processed_frames = 0
    num_scenes = self.source_dataset.num_rows
    for video in self.iterate_archive_contents(video_dataset.get_results_path(), staging_area=video_staging_area):
        # Check for 4CAT's metadata JSON and copy it
        if video.name == '.metadata.json':
            shutil.copy(video, staging_area)
        if video.name not in scenes:
            continue
        video_folder = staging_area.joinpath(video.stem)
        video_folder.mkdir(exist_ok=True)
        for scene in scenes[video.name]:
            scene_index = scene["id"].split("_").pop()
            scene_filename = video.stem + "_scene_" + str(scene_index) + ".jpeg"
            command = [
                shutil.which(self.config.get("video-downloader.ffmpeg_path")),
                "-i", shlex.quote(str(video)),
                "-vf", "select='eq(n\\," + scene["start_frame"] + ")'",
                "-vframes", "1",
                shlex.quote(str(video_folder.joinpath(scene_filename)))
            ]
            if frame_size != "no_modify":
                command += ["-s", shlex.quote(frame_size)]
            result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)
            # some ffmpeg error - log but continue
            if result.returncode != 0:
                self.dataset.log(
                    f"Error extracting frame for scene {scene_index} of video file {video.name}, skipping.")
                errors += 1
            processed_frames += 1
        self.dataset.update_status(f"Captured frames for {processed_frames} of {num_scenes} scenes")
        self.dataset.update_progress(processed_frames / self.source_dataset.num_rows)
    # Finish up
    # We've created a directory and folder structure here as opposed to a single folder with single files as
    # expected by self.write_archive_and_finish() so we use make_archive instead
    from shutil import make_archive
    make_archive(self.dataset.get_results_path().with_suffix(''), "zip", staging_area)
    if errors:
        self.dataset.update_status("Finished, but not all scenes could be captured. See dataset log for "
                                   "details.", is_final=True)
    # Remove staging areas
    shutil.rmtree(staging_area)
    shutil.rmtree(video_staging_area)
    self.dataset.finish(processed_frames)