dataeval 0.76.1__py3-none-any.whl → 0.82.0__py3-none-any.whl

dataeval/utils/data/collate.py

@@ -0,0 +1,103 @@
+"""
+Collate functions used with a PyTorch DataLoader to load data from MAITE compliant datasets.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Iterable, Sequence, TypeVar
+
+import numpy as np
+import torch
+from numpy.typing import NDArray
+
+from dataeval.typing import ArrayLike
+from dataeval.utils._array import as_numpy
+
+T_in = TypeVar("T_in")
+T_tgt = TypeVar("T_tgt")
+T_md = TypeVar("T_md")
+
+
+def list_collate_fn(
+    batch_data_as_singles: Iterable[tuple[T_in, T_tgt, T_md]],
+) -> tuple[Sequence[T_in], Sequence[T_tgt], Sequence[T_md]]:
+    """
+    A collate function that takes a batch of individual data points in the format
+    (input, target, metadata) and returns three lists: the input batch, the target batch,
+    and the metadata batch. This is useful for loading data with torch.utils.data.DataLoader
+    when the target and metadata are not tensors.
+
+    Parameters
+    ----------
+    batch_data_as_singles : An iterable of (input, target, metadata) tuples.
+
+    Returns
+    -------
+    tuple[Sequence[T_in], Sequence[T_tgt], Sequence[T_md]]
+        A tuple of three lists: the input batch, the target batch, and the metadata batch.
+    """
+    input_batch: list[T_in] = []
+    target_batch: list[T_tgt] = []
+    metadata_batch: list[T_md] = []
+    for input_datum, target_datum, metadata_datum in batch_data_as_singles:
+        input_batch.append(input_datum)
+        target_batch.append(target_datum)
+        metadata_batch.append(metadata_datum)
+
+    return input_batch, target_batch, metadata_batch
+
+
+def numpy_collate_fn(
+    batch_data_as_singles: Iterable[tuple[ArrayLike, T_tgt, T_md]],
+) -> tuple[NDArray[Any], Sequence[T_tgt], Sequence[T_md]]:
+    """
+    A collate function that takes a batch of individual data points in the format
+    (input, target, metadata) and returns the batched input as a single NumPy array with two
+    lists: the target batch, and the metadata batch. The inputs must be homogeneous arrays.
+
+    Parameters
+    ----------
+    batch_data_as_singles : An iterable of (ArrayLike, target, metadata) tuples.
+
+    Returns
+    -------
+    tuple[NDArray[Any], Sequence[T_tgt], Sequence[T_md]]
+        A tuple of a NumPy array and two lists: the input batch, the target batch, and the metadata batch.
+    """
+    input_batch: list[NDArray[Any]] = []
+    target_batch: list[T_tgt] = []
+    metadata_batch: list[T_md] = []
+    for input_datum, target_datum, metadata_datum in batch_data_as_singles:
+        input_batch.append(as_numpy(input_datum))
+        target_batch.append(target_datum)
+        metadata_batch.append(metadata_datum)
+
+    return np.stack(input_batch) if input_batch else np.array([]), target_batch, metadata_batch
+
+
+def torch_collate_fn(
+    batch_data_as_singles: Iterable[tuple[ArrayLike, T_tgt, T_md]],
+) -> tuple[torch.Tensor, Sequence[T_tgt], Sequence[T_md]]:
+    """
+    A collate function that takes a batch of individual data points in the format
+    (input, target, metadata) and returns the batched input as a single torch Tensor with two
+    lists: the target batch, and the metadata batch. The inputs must be homogeneous arrays.
+
+    Parameters
+    ----------
+    batch_data_as_singles : An iterable of (ArrayLike, target, metadata) tuples.
+
+    Returns
+    -------
+    tuple[torch.Tensor, Sequence[T_tgt], Sequence[T_md]]
+        A tuple of a torch Tensor and two lists: the input batch, the target batch, and the metadata batch.
+    """
+    input_batch: list[torch.Tensor] = []
+    target_batch: list[T_tgt] = []
+    metadata_batch: list[T_md] = []
+    for input_datum, target_datum, metadata_datum in batch_data_as_singles:
+        input_batch.append(torch.as_tensor(input_datum))
+        target_batch.append(target_datum)
+        metadata_batch.append(metadata_datum)
+
+    return torch.stack(input_batch) if input_batch else torch.tensor([]), target_batch, metadata_batch

dataeval/utils/data/datasets/__init__.py

@@ -0,0 +1,17 @@
+"""Provides access to common Computer Vision datasets."""
+
+from dataeval.utils.data.datasets._cifar10 import CIFAR10
+from dataeval.utils.data.datasets._milco import MILCO
+from dataeval.utils.data.datasets._mnist import MNIST
+from dataeval.utils.data.datasets._ships import Ships
+from dataeval.utils.data.datasets._voc import VOCDetection, VOCDetectionTorch, VOCSegmentation
+
+__all__ = [
+    "MNIST",
+    "Ships",
+    "CIFAR10",
+    "MILCO",
+    "VOCDetection",
+    "VOCDetectionTorch",
+    "VOCSegmentation",
+]

dataeval/utils/data/datasets/_base.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+__all__ = []
+
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any, Generic, Iterator, Literal, NamedTuple, Sequence, TypeVar
+
+from dataeval.utils.data.datasets._fileio import _ensure_exists
+from dataeval.utils.data.datasets._mixin import BaseDatasetMixin
+from dataeval.utils.data.datasets._types import (
+    AnnotatedDataset,
+    DatasetMetadata,
+    ImageClassificationDataset,
+    ObjectDetectionDataset,
+    ObjectDetectionTarget,
+    SegmentationDataset,
+    SegmentationTarget,
+    Transform,
+)
+
+_TArray = TypeVar("_TArray")
+_TTarget = TypeVar("_TTarget")
+_TRawTarget = TypeVar("_TRawTarget", list[int], list[str])
+
+
+class DataLocation(NamedTuple):
+    url: str
+    filename: str
+    md5: bool
+    checksum: str
+
+
+class BaseDataset(AnnotatedDataset[tuple[_TArray, _TTarget, dict[str, Any]]], Generic[_TArray, _TTarget, _TRawTarget]):
+    """
+    Base class for internet downloaded datasets.
+    """
+
+    # Each subclass should override the attributes below.
+    # Each resource tuple must contain:
+    #    'url': str, the URL to download from
+    #    'filename': str, the name of the file once downloaded
+    #    'md5': boolean, True if it's the checksum value is md5
+    #    'checksum': str, the associated checksum for the downloaded file
+    _resources: list[DataLocation]
+    _resource_index: int = 0
+    index2label: dict[int, str]
+
+    def __init__(
+        self,
+        root: str | Path,
+        download: bool = False,
+        image_set: Literal["train", "val", "test", "base"] = "train",
+        transforms: Transform[_TArray] | Sequence[Transform[_TArray]] | None = None,
+        verbose: bool = False,
+    ) -> None:
+        self._root: Path = root.absolute() if isinstance(root, Path) else Path(root).absolute()
+        transforms = transforms if transforms is not None else []
+        self.transforms: Sequence[Transform[_TArray]] = transforms if isinstance(transforms, Sequence) else [transforms]
+        self.image_set = image_set
+        self._verbose = verbose
+
+        # Internal Attributes
+        self._download = download
+        self._filepaths: list[str]
+        self._targets: _TRawTarget
+        self._datum_metadata: dict[str, list[Any]]
+        self._resource: DataLocation = self._resources[self._resource_index]
+        self._label2index = {v: k for k, v in self.index2label.items()}
+
+        self.metadata: DatasetMetadata = DatasetMetadata(
+            id=self._unique_id(),
+            index2label=self.index2label,
+            split=self.image_set,
+        )
+
+        # Load the data
+        self.path: Path = self._get_dataset_dir()
+        self._filepaths, self._targets, self._datum_metadata = self._load_data()
+        self.size: int = len(self._filepaths)
+
+    def __str__(self) -> str:
+        nt = "\n    "
+        title = f"{self.__class__.__name__} Dataset"
+        sep = "-" * len(title)
+        attrs = [f"{k.capitalize()}: {v}" for k, v in self.__dict__.items() if not k.startswith("_")]
+        return f"{title}\n{sep}{nt}{nt.join(attrs)}"
+
+    @property
+    def label2index(self) -> dict[str, int]:
+        return self._label2index
+
+    def __iter__(self) -> Iterator[tuple[_TArray, _TTarget, dict[str, Any]]]:
+        for i in range(len(self)):
+            yield self[i]
+
+    def _get_dataset_dir(self) -> Path:
+        # Create a designated folder for this dataset (named after the class)
+        if self._root.stem in [
+            self.__class__.__name__.lower(),
+            self.__class__.__name__.upper(),
+            self.__class__.__name__,
+        ]:
+            dataset_dir: Path = self._root
+        else:
+            dataset_dir: Path = self._root / self.__class__.__name__.lower()
+        if not dataset_dir.exists():
+            dataset_dir.mkdir(parents=True, exist_ok=True)
+        return dataset_dir
+
+    def _unique_id(self) -> str:
+        unique_id = f"{self.__class__.__name__}_{self.image_set}"
+        return unique_id
+
+    def _load_data(self) -> tuple[list[str], _TRawTarget, dict[str, Any]]:
+        """
+        Function to determine if data can be accessed or if it needs to be downloaded and/or extracted.
+        """
+        if self._verbose:
+            print(f"Determining if {self._resource.filename} needs to be downloaded.")
+
+        try:
+            result = self._load_data_inner()
+            if self._verbose:
+                print("No download needed, loaded data successfully.")
+        except FileNotFoundError:
+            _ensure_exists(*self._resource, self.path, self._root, self._download, self._verbose)
+            result = self._load_data_inner()
+        return result
+
+    @abstractmethod
+    def _load_data_inner(self) -> tuple[list[str], _TRawTarget, dict[str, Any]]: ...
+
+    def _transform(self, image: _TArray) -> _TArray:
+        """Function to transform the image prior to returning based on parameters passed in."""
+        for transform in self.transforms:
+            image = transform(image)
+        return image
+
+    def __len__(self) -> int:
+        return self.size
+
+
+class BaseICDataset(
+    BaseDataset[_TArray, _TArray, list[int]],
+    BaseDatasetMixin[_TArray],
+    ImageClassificationDataset[_TArray],
+):
+    """
+    Base class for image classification datasets.
+    """
+
+    def __getitem__(self, index: int) -> tuple[_TArray, _TArray, dict[str, Any]]:
+        """
+        Args
+        ----
+        index : int
+            Value of the desired data point
+
+        Returns
+        -------
+        tuple[TArray, TArray, dict[str, Any]]
+            Image, target, datum_metadata - where target is one-hot encoding of class.
+        """
+        # Get the associated label and score
+        label = self._targets[index]
+        score = self._one_hot_encode(label)
+        # Get the image
+        img = self._read_file(self._filepaths[index])
+        img = self._transform(img)
+
+        img_metadata = {key: val[index] for key, val in self._datum_metadata.items()}
+
+        return img, score, img_metadata
+
+
+class BaseODDataset(
+    BaseDataset[_TArray, ObjectDetectionTarget[_TArray], list[str]],
+    BaseDatasetMixin[_TArray],
+    ObjectDetectionDataset[_TArray],
+):
+    """
+    Base class for object detection datasets.
+    """
+
+    def __getitem__(self, index: int) -> tuple[_TArray, ObjectDetectionTarget[_TArray], dict[str, Any]]:
+        """
+        Args
+        ----
+        index : int
+            Value of the desired data point
+
+        Returns
+        -------
+        tuple[TArray, ObjectDetectionTarget[TArray], dict[str, Any]]
+            Image, target, datum_metadata - target.boxes returns boxes in x0, y0, x1, y1 format
+        """
+        # Grab the bounding boxes and labels from the annotations
+        boxes, labels, additional_metadata = self._read_annotations(self._targets[index])
+        # Get the image
+        img = self._read_file(self._filepaths[index])
+        img = self._transform(img)
+
+        target = ObjectDetectionTarget(self._as_array(boxes), self._as_array(labels), self._one_hot_encode(labels))
+
+        img_metadata = {key: val[index] for key, val in self._datum_metadata.items()}
+        img_metadata = img_metadata | additional_metadata
+
+        return img, target, img_metadata
+
+    @abstractmethod
+    def _read_annotations(self, annotation: str) -> tuple[list[list[float]], list[int], dict[str, Any]]: ...
+
+
+class BaseSegDataset(
+    BaseDataset[_TArray, SegmentationTarget[_TArray], list[str]],
+    BaseDatasetMixin[_TArray],
+    SegmentationDataset[_TArray],
+):
+    """
+    Base class for segmentation datasets.
+    """
+
+    _masks: Sequence[str]
+
+    def __getitem__(self, index: int) -> tuple[_TArray, SegmentationTarget[_TArray], dict[str, Any]]:
+        """
+        Args
+        ----
+        index : int
+            Value of the desired data point
+
+        Returns
+        -------
+        tuple[TArray, SegmentationTarget[TArray], dict[str, Any]]
+            Image, target, datum_metadata - target.mask returns the ground truth mask
+        """
+        # Grab the labels from the annotations
+        _, labels, additional_metadata = self._read_annotations(self._targets[index])
+        # Grab the ground truth masks
+        mask = self._read_file(self._masks[index])
+        # Get the image
+        img = self._read_file(self._filepaths[index])
+        img = self._transform(img)
+
+        target = SegmentationTarget(mask, self._as_array(labels), self._one_hot_encode(labels))
+
+        img_metadata = {key: val[index] for key, val in self._datum_metadata.items()}
+        img_metadata = img_metadata | additional_metadata
+
+        return img, target, img_metadata
+
+    @abstractmethod
+    def _read_annotations(self, annotation: str) -> tuple[list[list[float]], list[int], dict[str, Any]]: ...

dataeval/utils/data/datasets/_cifar10.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+__all__ = []
+
+from pathlib import Path
+from typing import Any, Literal, Sequence, TypeVar
+
+import numpy as np
+from numpy.typing import NDArray
+from PIL import Image
+
+from dataeval.utils.data.datasets._base import BaseICDataset, DataLocation
+from dataeval.utils.data.datasets._mixin import BaseDatasetNumpyMixin
+from dataeval.utils.data.datasets._types import Transform
+
+CIFARClassStringMap = Literal["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
+TCIFARClassMap = TypeVar("TCIFARClassMap", CIFARClassStringMap, int, list[CIFARClassStringMap], list[int])
+
+
+class CIFAR10(BaseICDataset[NDArray[Any]], BaseDatasetNumpyMixin):
+    """
+    `CIFAR10 <https://www.cs.toronto.edu/~kriz/cifar.html>`_ Dataset as NumPy arrays.
+
+    Parameters
+    ----------
+    root : str or pathlib.Path
+        Root directory of dataset where the ``mnist`` folder exists.
+    download : bool, default False
+        If True, downloads the dataset from the internet and puts it in root directory.
+        Class checks to see if data is already downloaded to ensure it does not create a duplicate download.
+    image_set : "train", "test" or "base", default "train"
+        If "base", returns all of the data to allow the user to create their own splits.
+    transforms : Transform | Sequence[Transform] | None, default None
+        Transform(s) to apply to the data.
+    verbose : bool, default False
+        If True, outputs print statements.
+
+    Attributes
+    ----------
+    index2label : dict
+        Dictionary which translates from class integers to the associated class strings.
+    label2index : dict
+        Dictionary which translates from class strings to the associated class integers.
+    path : Path
+        Location of the folder containing the data.
+    metadata : dict
+        Dictionary containing Dataset metadata, such as `id` which returns the dataset class name.
+    """
+
+    _resources = [
+        DataLocation(
+            url="https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz",
+            filename="cifar-10-binary.tar.gz",
+            md5=True,
+            checksum="c32a1d4ab5d03f1284b67883e8d87530",
+        ),
+    ]
+
+    index2label: dict[int, str] = {
+        0: "airplane",
+        1: "automobile",
+        2: "bird",
+        3: "cat",
+        4: "deer",
+        5: "dog",
+        6: "frog",
+        7: "horse",
+        8: "ship",
+        9: "truck",
+    }
+
+    def __init__(
+        self,
+        root: str | Path,
+        download: bool = False,
+        image_set: Literal["train", "test", "base"] = "train",
+        transforms: Transform[NDArray[Any]] | Sequence[Transform[NDArray[Any]]] | None = None,
+        verbose: bool = False,
+    ) -> None:
+        super().__init__(
+            root,
+            download,
+            image_set,
+            transforms,
+            verbose,
+        )
+
+    def _load_data_inner(self) -> tuple[list[str], list[int], dict[str, Any]]:
+        """Function to load in the file paths for the data and labels and retrieve metadata"""
+        file_meta = {"batch_num": []}
+        raw_data = []
+        labels = []
+        data_folder = self.path / "cifar-10-batches-bin"
+        save_folder = self.path / "images"
+        image_sets: dict[str, list[str]] = {"base": [], "train": [], "test": []}
+
+        # Process each batch file, skipping .meta and .html files
+        for entry in data_folder.iterdir():
+            if entry.suffix == ".bin":
+                batch_data, batch_labels = self._unpack_batch_files(entry)
+                raw_data.append(batch_data)
+                group = "train" if "test" not in entry.stem else "test"
+                name_split = entry.stem.split("_")
+                batch_num = int(name_split[-1]) - 1 if group == "train" else 5
+                file_names = [
+                    str(save_folder / f"{i + 10000 * batch_num:05d}_{self.index2label[label]}.png")
+                    for i, label in enumerate(batch_labels)
+                ]
+                image_sets["base"].extend(file_names)
+                image_sets[group].extend(file_names)
+
+                if self.image_set in (group, "base"):
+                    labels.extend(batch_labels)
+                    file_meta["batch_num"].extend([batch_num] * len(labels))
+
+        # Stack and reshape images
+        images = np.vstack(raw_data).reshape(-1, 3, 32, 32)
+
+        # Save the raw data into images if not already there
+        if not save_folder.exists():
+            save_folder.mkdir(exist_ok=True)
+            for i, file in enumerate(image_sets["base"]):
+                Image.fromarray(images[i].transpose(1, 2, 0).astype(np.uint8)).save(file)
+
+        return image_sets[self.image_set], labels, file_meta
+
+    def _unpack_batch_files(self, file_path: Path) -> tuple[NDArray[Any], list[int]]:
+        # Load pickle data with latin1 encoding
+        with file_path.open("rb") as f:
+            buffer = np.frombuffer(f.read(), "B")
+            labels = buffer[::3073]
+            pixels = np.delete(buffer, np.arange(0, buffer.size, 3073))
+            images = pixels.reshape(-1, 3072)
+        return images, labels.tolist()

dataeval/utils/data/datasets/_fileio.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+__all__ = []
+
+import hashlib
+import shutil
+import tarfile
+import zipfile
+from pathlib import Path
+
+import requests
+from tqdm import tqdm
+
+ARCHIVE_ENDINGS = [".zip", ".tar", ".tgz"]
+COMPRESS_ENDINGS = [".gz", ".bz2"]
+
+
+def _validate_file(fpath, file_md5, md5: bool = False, chunk_size=65535) -> bool:
+    hasher = hashlib.md5(usedforsecurity=False) if md5 else hashlib.sha256()
+    with open(fpath, "rb") as fpath_file:
+        while chunk := fpath_file.read(chunk_size):
+            hasher.update(chunk)
+    return hasher.hexdigest() == file_md5
+
+
+def _download_dataset(url: str, file_path: Path, timeout: int = 60) -> None:
+    """Download a single resource from its URL to the `data_folder`."""
+    error_msg = "URL fetch failure on {}: {} -- {}"
+    try:
+        response = requests.get(url, stream=True, timeout=timeout)
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        raise RuntimeError(f"{error_msg.format(url, e.response.status_code, e.response.reason)}") from e
+    except requests.exceptions.RequestException as e:
+        raise ValueError(f"{error_msg.format(url, 'Unknown error', str(e))}") from e
+
+    total_size = int(response.headers.get("content-length", 0))
+    block_size = 8192  # 8 KB
+    progress_bar = tqdm(total=total_size, unit="iB", unit_scale=True)
+
+    with open(file_path, "wb") as f:
+        for chunk in response.iter_content(block_size):
+            f.write(chunk)
+            progress_bar.update(len(chunk))
+    progress_bar.close()
+
+
+def _extract_zip_archive(file_path: Path, extract_to: Path) -> None:
+    """Extracts the zip file to the given directory."""
+    try:
+        with zipfile.ZipFile(file_path, "r") as zip_ref:
+            zip_ref.extractall(extract_to)
+            file_path.unlink()
+    except zipfile.BadZipFile:
+        raise FileNotFoundError(f"{file_path.name} is not a valid zip file, skipping extraction.")
+
+
+def _extract_tar_archive(file_path: Path, extract_to: Path) -> None:
+    """Extracts a tar file (or compressed tar) to the specified directory."""
+    try:
+        with tarfile.open(file_path, "r:*") as tar_ref:
+            tar_ref.extractall(extract_to)
+            file_path.unlink()
+    except tarfile.TarError:
+        raise FileNotFoundError(f"{file_path.name} is not a valid tar file, skipping extraction.")
+
+
+def _flatten_extraction(base_directory: Path, verbose: bool = False) -> None:
+    """
+    If the extracted folder contains only directories (and no files),
+    move all its subfolders to the dataset_dir and remove the now-empty folder.
+    """
+    for child in base_directory.iterdir():
+        if child.is_dir():
+            inner_list = list(child.iterdir())
+            if all(subchild.is_dir() for subchild in inner_list):
+                for subchild in child.iterdir():
+                    if verbose:
+                        print(f"Moving {subchild.stem} to {base_directory}")
+                    shutil.move(subchild, base_directory)
+
+                if verbose:
+                    print(f"Removing empty folder {child.stem}")
+                child.rmdir()
+
+                # Checking for additional placeholder folders
+                if len(inner_list) == 1:
+                    _flatten_extraction(base_directory, verbose)
+
+
+def _archive_extraction(file_ext, file_path, directory, compression: bool = False, verbose: bool = False):
+    """
+    Single function to extract and then flatten if necessary.
+    Recursively extracts nested zip files as well.
+    Extracts and flattens all folders to the base directory.
+    """
+    if file_ext != ".zip" or compression:
+        _extract_tar_archive(file_path, directory)
+    else:
+        _extract_zip_archive(file_path, directory)
+    # Look for nested zip files in the extraction directory and extract them recursively.
+    # Does NOT extract in place - extracts everything to directory
+    for child in directory.iterdir():
+        if child.suffix == ".zip":
+            if verbose:
+                print(f"Extracting nested zip: {child} to {directory}")
+            _extract_zip_archive(child, directory)
+
+    # Determine if there are nested folders and remove them
+    # Helps ensure there that data is at most one folder below main directory
+    _flatten_extraction(directory, verbose)
+
+
+def _ensure_exists(
+    url: str,
+    filename: str,
+    md5: bool,
+    checksum: str,
+    directory: Path,
+    root: Path,
+    download: bool = True,
+    verbose: bool = False,
+) -> None:
+    """
+    For each resource, download it if it doesn't exist in the dataset_dir.
+    If the resource is a zip file, extract it (including recursively extracting nested zips).
+    """
+    file_path = directory / str(filename)
+    alternate_path = root / str(filename)
+    _, file_ext = file_path.stem, file_path.suffix
+    compression = False
+    if file_ext in COMPRESS_ENDINGS:
+        file_ext = file_path.suffixes[0]
+        compression = True
+
+    check_path = alternate_path if alternate_path.exists() and not file_path.exists() else file_path
+
+    # Download file if it doesn't exist.
+    if not check_path.exists() and download:
+        if verbose:
+            print(f"Downloading {filename} from {url}")
+        _download_dataset(url, check_path)
+
+        if not _validate_file(check_path, checksum, md5):
+            raise Exception("File checksum mismatch. Remove current file and retry download.")
+
+        # If the file is a zip, tar or tgz extract it into the designated folder.
+        if file_ext in ARCHIVE_ENDINGS:
+            if verbose:
+                print(f"Extracting {filename}...")
+            _archive_extraction(file_ext, check_path, directory, compression, verbose)
+
+    elif not check_path.exists() and not download:
+        raise FileNotFoundError(
+            "Data could not be loaded with the provided root directory, ",
+            f"the file path to the file {filename} does not exist, ",
+            "and the download parameter is set to False.",
+        )
+    else:
+        if not _validate_file(check_path, checksum, md5):
+            raise Exception("File checksum mismatch. Remove current file and retry download.")
+        if verbose:
+            print(f"{filename} already exists, skipping download.")
+
+        if file_ext in ARCHIVE_ENDINGS:
+            if verbose:
+                print(f"Extracting {filename}...")
+            _archive_extraction(file_ext, check_path, directory, compression, verbose)