diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..541cc7a8
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,40 @@
+name: ci
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    name: Test - ${{ matrix.python-version }} - ${{matrix.os}}
+    runs-on: ${{matrix.os}}
+
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+        os: [ubuntu-latest, macOs-latest]
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+          enable-cache: true
+          cache-dependency-glob: "**/pyproject.toml"
+
+      - name: Check if cache used
+        if: steps.setup-uv.outputs.cache-hit == 'true'
+        run: echo "Cache was restored"
+
+      - name: Set up python env
+        run: |
+          uv venv --python  ${{ matrix.python-version }}
+          uv sync --dev
+
+      - name: Run pre-commit
+        continue-on-error: true
+        run: make pre-commit
+
+      - name: Run tests
+        # For example, using `pytest`
+        run: make test
diff --git a/.gitignore b/.gitignore
index a979c7c6..49ea5f3f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -141,7 +141,6 @@ __MACOSX
 # Extra directories/files
 /**data*/
 
-**/**test*.*
 !tests/*/*
 agml/_helios
 agml/helios_config.sh
@@ -161,6 +160,7 @@ agml/models/training/*.log
 agml/models/training/*.err
 agml/models/training/*.out
 agml/models/training/*.csv
-.*/
+# .*/
 /
 *.pptx
+.ruff_cache
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1d35be08..3400045c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 # Contributing Guidelines
 
-Thank you for choosing to contribute to AgML! 
+Thank you for choosing to contribute to AgML!
 
 ## Contributing Data
 
@@ -29,15 +29,15 @@ Image classification datasets are organized in the following directory tree:
     └── <label 2>
         ├── image1.png
         ├── image2.png
-        └── image3.png               
+        └── image3.png
 ```
 
 The `AgMLDataLoader` generates a mapping between each of the label names "label 1", "label 2", etc.,
-and a numerical value. 
+and a numerical value.
 
 #### Object Detection
 
-Object detection datasets are constructed using COCO JSON formatting. For a general overview, see 
+Object detection datasets are constructed using COCO JSON formatting. For a general overview, see
 [https://cocodataset.org/#format-data](https://cocodataset.org/#format-data).
 Another good resource is [https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/cd-transform-coco.html](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/cd-transform-coco.html).
 Once you have the images and the bounding box annotations, this involves generating a dictionary with four keys:
@@ -75,7 +75,7 @@ The dictionary containing this information should be written to a file called `a
     └── images
         ├── image1.png
         ├── image2.png
-        └── image3.png              
+        └── image3.png
 ```
 
 #### Semantic Segmentation
@@ -104,7 +104,7 @@ The directory tree should look like follows:
 ## Contributing a Dataset
 
 If you've found a new dataset that *isn't already being used* in AgML and you want to add it, there's a few things you
-need to do. 
+need to do.
 
 Any preprocessing code being used for the dataset can be kept in `agml/_internal/preprocess.py`, by adding an `elif` statement
 to the `preprocess()` method with the dataset name. If there is no preprocessing code, then just put a `pass` statement in the block.
@@ -164,7 +164,7 @@ then put "worldwide" for both "continent" and "country".
 | Dataset Format | `ml_task` | `annotation_format` |
 | :------------: | :-------: | :-----------------: |
 | Image Classification | `image_classification` | `directory_names` |
-| Object Detection | `object_detection` | `coco_json` | 
+| Object Detection | `object_detection` | `coco_json` |
 | Semantic Segmentation | `semantic_segmentation` | `image` |
 
 
@@ -184,3 +184,38 @@ If the dataset has no license or has no citation, leave the corresponding lines
 Once you've readied the dataset, create a new pull request on the AgML repository.
 We will then review the changes and review next steps for adding the dataset into AgML's public data storage.
 
+
+## Developement Guidelines
+
+
+### Installing uv
+Dependencies and admin actions are done using `uv`. To Install uv follow the guidelines in  https://docs.astral.sh/uv/getting-started/installation/, it is recommended to use the standalone installation.
+
+
+### Building Project
+
+The build the associated wheels simply run:
+
+```
+make build
+```
+
+To sync the dependencies simply run:
+
+```
+uv sync
+```
+
+### Running tests
+
+```
+make test
+```
+
+### Running scripts
+
+For running scripts or one-offs using the project's installed enviroment
+
+```
+uv run python <script>
+```
diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..4efc8601
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,74 @@
+
+SHELL := bash
+
+version := 0.7.0
+
+src.python := $(shell find ./agml -type f -name "*.py" || :)
+test.python := $(shell find ./tests -type f -name "*.py" || :)
+
+uv.project.enviroment := .venv
+dist.dir := dist
+build.wheel := $(dist.dir)/agml-$(version).tar.gz
+
+
+
+
+
+.PHONY: help
+help: ## Print the help screen.
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":|:[[:space:]].*?##"}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+# Setup and Build
+
+
+install: setup ## Installing dependencies
+	uv sync
+
+setup: ## Setup the project.
+	uv venv $(uv.project.enviroment)
+
+
+$(build.wheel): $(src.python) ## Build wheels
+	uv build -o $(dist.dir)
+
+build: $(build.wheel) ## Build the distribution wheel.
+
+test: $(test.python) $(src.python) ## Run tests
+	uv run pytest -c=config/pytest.ini $(test.python)
+
+
+# Quality Checks
+
+.PHONY: pre-commit
+pre-commit: check-format lint check-types docstring-coverage
+
+
+.PHONY: check-types
+check-types: ## Run mypy to check type definitions.
+	uv run mypy --config=config/mypy.ini $(src.python) $(test.python)
+
+
+.PHONY: check-format
+check-format: ## Check ruff format
+	uv run ruff format --check --config=config/ruff.toml $(src.python) $(test.python)
+
+
+.PHONY: lint
+lint: ## Run ruff Code Linter
+	uv run ruff check --config=config/ruff.toml $(src.python) $(test.python)
+
+.PHONY:docstring-coverage
+docstring-coverage: ## Compute docstring coverage
+	uv run interrogate -c config/interrogate.toml .
+
+# Automated Quality fixes
+
+.PHONY: lint-fix
+lint-fix: ## Fix ruff Lint issues
+	uv run ruff check --fix --config=config/ruff.toml $(src.python) $(test.python)
+
+
+.PHONY: format
+format: ## Run ruff format (Includes sorting of imports)
+	uv run ruff check --select I --config=config/ruff.toml --fix
+	uv run ruff format --config=config/ruff.toml $(src.python) $(test.python)
diff --git a/agml/__init__.py b/agml/__init__.py
index b7bfc65b..77b0382f 100644
--- a/agml/__init__.py
+++ b/agml/__init__.py
@@ -12,27 +12,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = '0.7.0'
-__all__ = ['data', 'synthetic', 'backend', 'viz', 'io']
+__version__ = "0.7.0"
+__all__ = ["data", "synthetic", "backend", "viz", "io"]
 
 
 # If AgML is being imported for the first time, then we need to setup
 # the module, namely prepping the config file.
 def _setup():
-    import os as _os
     import json as _json
-    if not _os.path.exists(_os.path.expanduser('~/.agml')):
-        _os.makedirs(_os.path.expanduser('~/.agml'))
-        with open(_os.path.join(
-                _os.path.expanduser('~/.agml/config.json')), 'w') as f:
-            _json.dump({'data_path': _os.path.expanduser('~/.agml/datasets'),
-                        'viz_backend': 'matplotlib'}, f)
-_setup(); del _setup # noqa
+    import os as _os
 
-
-# There are no top-level imported functions or classes, only the modules.
-from . import data, backend, synthetic, viz, io
+    if not _os.path.exists(_os.path.expanduser("~/.agml")):
+        _os.makedirs(_os.path.expanduser("~/.agml"))
+        with open(_os.path.join(_os.path.expanduser("~/.agml/config.json")), "w") as f:
+            _json.dump(
+                {
+                    "data_path": _os.path.expanduser("~/.agml/datasets"),
+                    "viz_backend": "matplotlib",
+                },
+                f,
+            )
 
 
+_setup()
+del _setup  # noqa
 
 
+# There are no top-level imported functions or classes, only the modules.
+from . import backend, data, io, synthetic, viz
diff --git a/agml/_internal/preprocess.py b/agml/_internal/preprocess.py
index 0e767ea9..226acb85 100644
--- a/agml/_internal/preprocess.py
+++ b/agml/_internal/preprocess.py
@@ -20,28 +20,31 @@
 to install the necessary preprocessing packages.
 """
 
-import os
-import sys
-import json
-import glob
-import shutil
 import argparse
 import csv
+import glob
+import json
+import os
+import shutil
+import sys
 
 import cv2
 import numpy as np
 import pandas as pd
-
 from PIL import Image
 
-from agml.utils.logging import tqdm
-from agml.utils.io import create_dir, nested_dir_list, get_dir_list, get_file_list
-from agml.utils.data import load_public_sources
 from agml._internal.process_utils import (
-    read_txt_file, get_image_info, get_label2id,
-    convert_bbox_to_coco, get_coco_annotation_from_obj,
-    convert_xmls_to_cocojson, move_segmentation_dataset,
+    convert_bbox_to_coco,
+    convert_xmls_to_cocojson,
+    get_coco_annotation_from_obj,
+    get_image_info,
+    get_label2id,
+    move_segmentation_dataset,
+    read_txt_file,
 )
+from agml.utils.data import load_public_sources
+from agml.utils.io import create_dir, get_dir_list, get_file_list, nested_dir_list
+from agml.utils.logging import tqdm
 
 
 class PublicDataPreprocessor(object):
@@ -56,8 +59,8 @@ class PublicDataPreprocessor(object):
 
     def __init__(self, data_dir):
         self.data_dir = os.path.abspath(data_dir)
-        self.data_original_dir = os.path.join(self.data_dir, 'original')
-        self.data_processed_dir = os.path.join(self.data_dir, 'processed')
+        self.data_original_dir = os.path.join(self.data_dir, "original")
+        self.data_processed_dir = os.path.join(self.data_dir, "processed")
         self.data_sources = load_public_sources()
 
     def preprocess(self, dataset_name):
@@ -90,7 +93,7 @@ def vine_virus_photo_dataset(self, dataset_name):
         for cls in classes:
             class_path = os.path.join(base_path, cls)
             for img in os.listdir(class_path):
-                if img.endswith(('jpg', 'png', 'jpeg', 'JPG')):
+                if img.endswith(("jpg", "png", "jpeg", "JPG")):
                     img_path = os.path.join(class_path, img)
                     shutil.copyfile(img_path, os.path.join(output_path, cls, img))
 
@@ -117,7 +120,7 @@ def corn_maize_leaf_disease(self, dataset_name):
         for cls in classes:
             class_path = os.path.join(base_path, cls)
             for img in os.listdir(class_path):
-                if img.endswith(('jpg', 'png', 'jpeg', 'JPG')):
+                if img.endswith(("jpg", "png", "jpeg", "JPG")):
                     img_path = os.path.join(class_path, img)
 
                     # Open the image using Pillow
@@ -133,14 +136,14 @@ def corn_maize_leaf_disease(self, dataset_name):
                         # Convert back to PIL Image to save
                         processed_image = Image.fromarray(img_array)
 
-                        if processed_image.mode == 'RGBA':
-                            processed_image = processed_image.convert('RGB')
+                        if processed_image.mode == "RGBA":
+                            processed_image = processed_image.convert("RGB")
 
                         # Save the processed image to the output directory
                         processed_image.save(os.path.join(output_path, cls, img))
 
         print(f"Dataset {dataset_name} has been preprocessed and saved to {output_path}")
-    
+
     def tomato_leaf_disease(self, dataset_name):
         """Preprocesses the Tomato Leaf Disease Dataset."""
         # Get the dataset directory directly (no need for 'original' directory)
@@ -162,7 +165,7 @@ def tomato_leaf_disease(self, dataset_name):
         for cls in classes:
             class_path = os.path.join(base_path, cls)
             for img in os.listdir(class_path):
-                if img.endswith(('jpg', 'png', 'jpeg', 'JPG')):
+                if img.endswith(("jpg", "png", "jpeg", "JPG")):
                     img_path = os.path.join(class_path, img)
 
                     # Open the image using Pillow
@@ -178,8 +181,8 @@ def tomato_leaf_disease(self, dataset_name):
                         # Convert back to PIL Image to save
                         processed_image = Image.fromarray(img_array)
 
-                        if processed_image.mode == 'RGBA':
-                            processed_image = processed_image.convert('RGB')
+                        if processed_image.mode == "RGBA":
+                            processed_image = processed_image.convert("RGB")
 
                         # Save the processed image to the output directory
                         processed_image.save(os.path.join(output_path, cls, img))
@@ -189,21 +192,21 @@ def tomato_leaf_disease(self, dataset_name):
     def bean_disease_uganda(self, dataset_name):
         # Get the dataset classes and paths
         base_path = os.path.join(self.data_original_dir, dataset_name)
-        dirs = ['train', 'validation', 'test']
+        dirs = ["train", "validation", "test"]
         classes = sorted(os.listdir(os.path.join(base_path, dirs[0])))[1:]
 
         # Construct output directories
         output = os.path.join(self.data_processed_dir, dataset_name)
-        os.makedirs(output, exist_ok = True)
+        os.makedirs(output, exist_ok=True)
         for cls in classes:
-            os.makedirs(os.path.join(output, cls), exist_ok = True)
+            os.makedirs(os.path.join(output, cls), exist_ok=True)
 
         # Move the dataset
         for dir_ in dirs:
             for cls in classes:
                 path = os.path.join(base_path, dir_, cls)
                 for p in os.listdir(path):
-                    if p.endswith('jpg') or p.endswith('png'):
+                    if p.endswith("jpg") or p.endswith("png"):
                         img = os.path.join(base_path, dir_, cls, p)
                         shutil.copyfile(img, os.path.join(output, cls, p))
 
@@ -219,32 +222,31 @@ def crop_weeds_greece(self, dataset_name):
     def rangeland_weeds_australia(self, dataset_name):
         # Get the file information.
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        images = get_file_list(os.path.join(dataset_dir, 'images'))
-        df = pd.read_csv(os.path.join(dataset_dir, 'labels.csv'))
+        images = get_file_list(os.path.join(dataset_dir, "images"))
+        df = pd.read_csv(os.path.join(dataset_dir, "labels.csv"))
 
         # Construct the new structure.
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        unique_labels = np.unique(df['Species'])
+        unique_labels = np.unique(df["Species"])
         for unique_label in unique_labels:
-            os.makedirs(os.path.join(
-                processed_dir, unique_label.title()), exist_ok = True)
-        for file in tqdm(images, desc = "Moving Images", file = sys.stdout):
-            save_dir = df.loc[df['Filename'] == os.path.basename(file)]['Species'].values[0].title()
+            os.makedirs(os.path.join(processed_dir, unique_label.title()), exist_ok=True)
+        for file in tqdm(images, desc="Moving Images", file=sys.stdout):
+            save_dir = df.loc[df["Filename"] == os.path.basename(file)]["Species"].values[0].title()
             shutil.copyfile(
-                os.path.join(dataset_dir, 'images', file),
-                os.path.join(processed_dir, save_dir, os.path.basename(file))
+                os.path.join(dataset_dir, "images", file),
+                os.path.join(processed_dir, save_dir, os.path.basename(file)),
             )
 
     def fruit_detection_worldwide(self, dataset_name):
         # Get the dataset directory
-        dataset_dir = os.path.join(self.data_original_dir, dataset_name, 'datasets')
+        dataset_dir = os.path.join(self.data_original_dir, dataset_name, "datasets")
 
         # Get folder list
         dataset_folders = get_dir_list(dataset_dir)
         label2id = get_label2id(dataset_folders)
         anno_data_all = []
         for folder in dataset_folders:
-            annotations = ['test_RGB.txt', 'train_RGB.txt']
+            annotations = ["test_RGB.txt", "train_RGB.txt"]
             dataset_path = os.path.join(dataset_dir, folder)
             # @TODO: Make separate json files for train and test?
             for anno_file_name in annotations:
@@ -253,7 +255,7 @@ def fruit_detection_worldwide(self, dataset_name):
                     anno_data = read_txt_file(os.path.join(dataset_path, anno_file_name))
                 except:
                     try:
-                        anno_data = read_txt_file(os.path.join(dataset_path, anno_file_name + '.txt'))
+                        anno_data = read_txt_file(os.path.join(dataset_path, anno_file_name + ".txt"))
                     except Exception as e:
                         raise e
 
@@ -267,9 +269,9 @@ def fruit_detection_worldwide(self, dataset_name):
                 anno_data_all += anno_data
 
         # Process annotation files
-        save_dir_anno = os.path.join(self.data_processed_dir, dataset_name, 'annotations')
+        save_dir_anno = os.path.join(self.data_processed_dir, dataset_name, "annotations")
         create_dir(save_dir_anno)
-        output_json_file = os.path.join(save_dir_anno, 'instances.json')
+        output_json_file = os.path.join(save_dir_anno, "instances.json")
 
         general_info = {
             "description": "fruits dataset",
@@ -277,49 +279,46 @@ def fruit_detection_worldwide(self, dataset_name):
             "version": "1.0",
             "year": 2018,
             "contributor": "Inkyu Sa",
-            "date_created": "2018/11/12"
+            "date_created": "2018/11/12",
         }
 
         # Process image files
-        output_img_path = os.path.join(
-            self.data_processed_dir, dataset_name, 'images')
+        output_img_path = os.path.join(self.data_processed_dir, dataset_name, "images")
         create_dir(output_img_path)
 
-        convert_bbox_to_coco(
-            anno_data_all, label2id, output_json_file,
-            output_img_path, general_info)
+        convert_bbox_to_coco(anno_data_all, label2id, output_json_file, output_img_path, general_info)
 
-    def apple_detection_usa(self, dataset_name, fix = False):
+    def apple_detection_usa(self, dataset_name, fix=False):
         # Just a quick fix to clip over-sized bounding boxes.
         if fix:
             # Load in the annotations.
             dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-            with open(os.path.join(dataset_dir, 'annotations.json'), 'r') as f:
+            with open(os.path.join(dataset_dir, "annotations.json"), "r") as f:
                 annotations = json.load(f)
 
             # Get the images and all of their heights/widths.
-            images = annotations['images']
+            images = annotations["images"]
             image_id_content_map = {}
             for image in images:
-                image_id_content_map[image['id']] = (image['height'], image['width'])
+                image_id_content_map[image["id"]] = (image["height"], image["width"])
 
             # Load all of the annotations.
             new_annotations = []
-            for a in annotations['annotations']:
+            for a in annotations["annotations"]:
                 new_a = a.copy()
-                height, width = image_id_content_map[a['image_id']]
-                (x, y, w, h) = a['bbox']
+                height, width = image_id_content_map[a["image_id"]]
+                (x, y, w, h) = a["bbox"]
                 x1, y1, x2, y2 = x, y, x + w, y + h
                 x1 = np.clip(x1, 0, width)
                 x2 = np.clip(x2, 0, width)
                 y1 = np.clip(y1, 0, height)
                 y2 = np.clip(y2, 0, height)
-                new_a['bbox'] = [int(i) for i in [x1, y1, x2 - x1, y2 - y1]]
+                new_a["bbox"] = [int(i) for i in [x1, y1, x2 - x1, y2 - y1]]
                 new_annotations.append(new_a)
 
             # Save the annotations.
-            annotations['annotations'] = new_annotations
-            with open(os.path.join(dataset_dir, 'annotations.json'), 'w') as f:
+            annotations["annotations"] = new_annotations
+            with open(os.path.join(dataset_dir, "annotations.json"), "w") as f:
                 json.dump(annotations, f)
             return
 
@@ -327,7 +326,7 @@ def apple_detection_usa(self, dataset_name, fix = False):
         resize = 1.0
 
         # Read public_datasources.json to get class information
-        category_info = self.data_sources[dataset_name]['classes']
+        category_info = self.data_sources[dataset_name]["classes"]
         labels_str = []
         labels_ids = []
         for info in category_info:
@@ -338,7 +337,7 @@ def apple_detection_usa(self, dataset_name, fix = False):
 
         # Task 1: Image classification
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        obj_Detection_data = os.path.join(dataset_dir, 'Dataset')
+        obj_Detection_data = os.path.join(dataset_dir, "Dataset")
 
         # get folders
         plant_folders = nested_dir_list(obj_Detection_data)
@@ -354,7 +353,7 @@ def apple_detection_usa(self, dataset_name, fix = False):
                 anno_line = []
                 anno_path = os.path.join(full_path, anno_file)
                 # Opening annotation file
-                anno_data = read_txt_file(anno_path, delimiter=',')[0]
+                anno_data = read_txt_file(anno_path, delimiter=",")[0]
 
                 for i, anno in enumerate(anno_data):
                     new_anno = [os.path.join(dataset_dir, anno_data[i][0])]
@@ -377,9 +376,9 @@ def apple_detection_usa(self, dataset_name, fix = False):
                 anno_data_all += anno_data
 
         # Process annotation files
-        save_dir_anno = os.path.join(self.data_processed_dir, dataset_name, 'annotations')
+        save_dir_anno = os.path.join(self.data_processed_dir, dataset_name, "annotations")
         create_dir(save_dir_anno)
-        output_json_file = os.path.join(save_dir_anno, 'instances.json')
+        output_json_file = os.path.join(save_dir_anno, "instances.json")
 
         general_info = {
             "description": "apple dataset",
@@ -387,31 +386,34 @@ def apple_detection_usa(self, dataset_name, fix = False):
             "version": "1.0",
             "year": 2019,
             "contributor": "Bhusal, Santosh, Karkee, Manoj, Zhang, Qin",
-            "date_created": "2019/04/20"
+            "date_created": "2019/04/20",
         }
 
         # Process image files
-        output_img_path = os.path.join(self.data_processed_dir, dataset_name, 'images')
+        output_img_path = os.path.join(self.data_processed_dir, dataset_name, "images")
         create_dir(output_img_path)
         convert_bbox_to_coco(
             anno_data_all,
             label2id,
             output_json_file,
             output_img_path,
-            general_info, None, None,
-            get_label_from_folder = False,
-            resize = resize, add_foldername = True)
+            general_info,
+            None,
+            None,
+            get_label_from_folder=False,
+            resize=resize,
+            add_foldername=True,
+        )
 
     def mango_detection_australia(self, dataset_name):
         # resize the dataset
         resize = 1.0
 
         # Read public_datasources.json to get class information
-        datasource_file = os.path.join(
-            os.path.dirname(__file__), "../_assets/public_datasources.json")
+        datasource_file = os.path.join(os.path.dirname(__file__), "../_assets/public_datasources.json")
         with open(datasource_file) as f:
             data = json.load(f)
-            category_info = data[dataset_name]['crop_types']
+            category_info = data[dataset_name]["crop_types"]
             labels_str = []
             labels_ids = []
             for info in category_info:
@@ -427,19 +429,15 @@ def mango_detection_australia(self, dataset_name):
         # Get image file and xml file
         all_files = get_file_list(ann_dir)
         anno_files = [os.path.join(ann_dir, x) for x in all_files if "xml" in x]
-        img_files = [x.replace(".xml", ".jpg").replace(
-            "Annotations", "JPEGImages") for x in anno_files]
+        img_files = [x.replace(".xml", ".jpg").replace("Annotations", "JPEGImages") for x in anno_files]
 
         # Process annotation files
-        save_dir_anno = os.path.join(
-            self.data_processed_dir, dataset_name, 'annotations')
+        save_dir_anno = os.path.join(self.data_processed_dir, dataset_name, "annotations")
         create_dir(save_dir_anno)
-        output_json_file = os.path.join(
-            save_dir_anno, 'instances.json')
+        output_json_file = os.path.join(save_dir_anno, "instances.json")
 
         # Process image files
-        output_img_path = os.path.join(
-            self.data_processed_dir, dataset_name, 'images')
+        output_img_path = os.path.join(self.data_processed_dir, dataset_name, "images")
         create_dir(output_img_path)
 
         general_info = {
@@ -448,36 +446,36 @@ def mango_detection_australia(self, dataset_name):
             "version": "1.0",
             "year": 2019,
             "contributor": "Anand Koirala, Kerry Walsh, Z Wang, C McCarthy",
-            "date_created": "2019/02/25"
+            "date_created": "2019/02/25",
         }
 
         convert_xmls_to_cocojson(
             general_info,
-            annotation_paths = anno_files,
-            img_paths = img_files,
-            label2id = label2id,
-            name_converter = name_converter,
-            output_jsonpath = output_json_file,
-            output_imgpath = output_img_path,
-            extract_num_from_imgid = True
+            annotation_paths=anno_files,
+            img_paths=img_files,
+            label2id=label2id,
+            name_converter=name_converter,
+            output_jsonpath=output_json_file,
+            output_imgpath=output_img_path,
+            extract_num_from_imgid=True,
         )
-    
+
     def tomato_ripeness_detection(self, dataset_name):
         pass
 
     def cotton_seedling_counting(self, dataset_name):
         # Get all of the relevant data
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        image_dir = os.path.join(dataset_dir, 'Images')
+        image_dir = os.path.join(dataset_dir, "Images")
         images = sorted([os.path.join(image_dir, i) for i in os.listdir(image_dir)])
-        with open(os.path.join(dataset_dir, 'Images.json'), 'r') as f:
+        with open(os.path.join(dataset_dir, "Images.json"), "r") as f:
             annotations = json.load(f)
 
         # Get all of the unique labels
         labels = []
-        for label_set in annotations['frames'].values():
+        for label_set in annotations["frames"].values():
             for individual_set in label_set:
-                labels.extend(individual_set['tags'])
+                labels.extend(individual_set["tags"])
         labels = np.unique(labels).tolist()
         label2id = get_label2id(labels)  # noqa
 
@@ -486,139 +484,145 @@ def cotton_seedling_counting(self, dataset_name):
         annotation_data = []
         valid_paths = []  # some paths are not in the annotations, track the ones which are
         for indx, (img_path, annotation) in enumerate(
-                zip(tqdm(images, file = sys.stdout, desc = "Generating Data"),
-                    annotations['frames'].values())):
+            zip(
+                tqdm(images, file=sys.stdout, desc="Generating Data"),
+                annotations["frames"].values(),
+            )
+        ):
             image_data.append(get_image_info(img_path, indx))
             valid_paths.append(img_path)
             for a_set in annotation:
                 formatted_set = [
-                    a_set['x1'], a_set['y1'], a_set['x2'], a_set['y2'],
-                    label2id[a_set['tags'][0]]]
-                base_annotation_data = get_coco_annotation_from_obj(formatted_set, a_set['name'])
-                base_annotation_data['image_id'] = indx + 1
+                    a_set["x1"],
+                    a_set["y1"],
+                    a_set["x2"],
+                    a_set["y2"],
+                    label2id[a_set["tags"][0]],
+                ]
+                base_annotation_data = get_coco_annotation_from_obj(formatted_set, a_set["name"])
+                base_annotation_data["image_id"] = indx + 1
                 annotation_data.append(base_annotation_data)
 
         # Set up the annotation dictionary
         all_annotation_data = {
-            "images": [], "type": "instances",
-            "annotations": [], "categories": [],
+            "images": [],
+            "type": "instances",
+            "annotations": [],
+            "categories": [],
             "info": {
                 "description": "cotton seedling counting dataset",
                 "url": "https://figshare.com/s/616956f8633c17ceae9b",
                 "version": "1.0",
                 "year": 2019,
                 "contributor": "Yu Jiang",
-                "date_created": "2019/11/23"
-            }
+                "date_created": "2019/11/23",
+            },
         }
 
         # Populate the annotation dictionary
         for label, label_id in label2id.items():
-            category_info = {'supercategory': 'none', 'id': label_id, 'name': label}
-            all_annotation_data['categories'].append(category_info)
-        all_annotation_data['images'] = image_data
-        all_annotation_data['annotations'] = annotation_data
+            category_info = {"supercategory": "none", "id": label_id, "name": label}
+            all_annotation_data["categories"].append(category_info)
+        all_annotation_data["images"] = image_data
+        all_annotation_data["annotations"] = annotation_data
 
         # Recreate the dataset and zip it
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        processed_img_dir = os.path.join(processed_dir, 'images')
+        processed_img_dir = os.path.join(processed_dir, "images")
         if os.path.exists(processed_dir):
             shutil.rmtree(processed_dir)
-        os.makedirs(processed_dir, exist_ok = True)
-        os.makedirs(processed_img_dir, exist_ok = True)
+        os.makedirs(processed_dir, exist_ok=True)
+        os.makedirs(processed_img_dir, exist_ok=True)
         for path in images:
             if path not in valid_paths:
                 continue
             shutil.copyfile(path, os.path.join(processed_img_dir, os.path.basename(path)))
-        with open(os.path.join(processed_dir, 'annotations.json'), 'w') as f:
-            json.dump(all_annotation_data, f, indent = 4)
+        with open(os.path.join(processed_dir, "annotations.json"), "w") as f:
+            json.dump(all_annotation_data, f, indent=4)
 
         # Zip the dataset
-        shutil.make_archive(
-            processed_dir, "zip", os.path.dirname(processed_dir))
+        shutil.make_archive(processed_dir, "zip", os.path.dirname(processed_dir))
 
     def apple_flower_segmentation(self, dataset_name):
         # Get all of the relevant data.
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        apple_a_dir = os.path.join(dataset_dir, 'FlowerImages')
+        apple_a_dir = os.path.join(dataset_dir, "FlowerImages")
         apple_a_images = os.listdir(apple_a_dir)
-        apple_a_label_dir = os.path.join(dataset_dir, 'AppleA_Labels')
+        apple_a_label_dir = os.path.join(dataset_dir, "AppleA_Labels")
         apple_a_labels = os.listdir(apple_a_label_dir)
-        apple_b_dir = os.path.join(dataset_dir, 'AppleB')
+        apple_b_dir = os.path.join(dataset_dir, "AppleB")
         apple_b_images = os.listdir(apple_b_dir)
-        apple_b_label_dir = os.path.join(dataset_dir, 'AppleB_Labels')
+        apple_b_label_dir = os.path.join(dataset_dir, "AppleB_Labels")
         apple_b_labels = os.listdir(apple_b_label_dir)
 
         # Map image filenames with their corresponding labels.
         fname_map_a, fname_map_b = {}, {}
         for fname in apple_a_images:
-            fname_id = str(int(float(
-                os.path.splitext(fname)[0].split('_')[-1]))) + ".png"
+            fname_id = str(int(float(os.path.splitext(fname)[0].split("_")[-1]))) + ".png"
             if fname_id in apple_a_labels:
-                fname_map_a[os.path.join(apple_a_dir, fname)] \
-                    = os.path.join(apple_a_label_dir, fname_id)
+                fname_map_a[os.path.join(apple_a_dir, fname)] = os.path.join(apple_a_label_dir, fname_id)
         for fname in apple_b_images:
-            fname_id = str(int(float(
-                os.path.splitext(fname)[0].split('_')[-1]))) + ".png"
+            fname_id = str(int(float(os.path.splitext(fname)[0].split("_")[-1]))) + ".png"
             if fname_id in apple_b_labels:
-                fname_map_b[os.path.join(apple_b_dir, fname)] \
-                    = os.path.join(apple_b_label_dir, fname_id)
+                fname_map_b[os.path.join(apple_b_dir, fname)] = os.path.join(apple_b_label_dir, fname_id)
 
         # Process and move the images.
-        processed_dir = os.path.join(
-            self.data_processed_dir, dataset_name)
-        os.makedirs(processed_dir, exist_ok = True)
-        processed_image_dir = os.path.join(processed_dir, 'images')
-        os.makedirs(processed_image_dir, exist_ok = True)
-        processed_annotation_dir = os.path.join(processed_dir, 'annotations')
-        os.makedirs(processed_annotation_dir, exist_ok = True)
-        for image_path, label_path in tqdm(
-                fname_map_a.items(), desc = "Processing Part A", file = sys.stdout):
+        processed_dir = os.path.join(self.data_processed_dir, dataset_name)
+        os.makedirs(processed_dir, exist_ok=True)
+        processed_image_dir = os.path.join(processed_dir, "images")
+        os.makedirs(processed_image_dir, exist_ok=True)
+        processed_annotation_dir = os.path.join(processed_dir, "annotations")
+        os.makedirs(processed_annotation_dir, exist_ok=True)
+        for image_path, label_path in tqdm(fname_map_a.items(), desc="Processing Part A", file=sys.stdout):
             image = cv2.resize(cv2.imread(image_path), (2074, 1382))
             label = cv2.resize(cv2.imread(label_path), (2074, 1382)) // 255
             label_path = os.path.basename(label_path)
             out_image_path = os.path.join(processed_image_dir, label_path)
             out_label_path = os.path.join(processed_annotation_dir, label_path)
-            cv2.imwrite(out_image_path.replace('.png', '.jpg'), image)
+            cv2.imwrite(out_image_path.replace(".png", ".jpg"), image)
             cv2.imwrite(out_label_path, label)
-        for image_path, label_path in tqdm(
-                fname_map_b.items(), desc = "Processing Part B", file = sys.stdout):
+        for image_path, label_path in tqdm(fname_map_b.items(), desc="Processing Part B", file=sys.stdout):
             image = cv2.resize(cv2.imread(image_path), (2074, 1382))
             label = cv2.resize(cv2.imread(label_path), (2074, 1382)) // 255
             label_path = os.path.basename(label_path)
             out_image_path = os.path.join(processed_image_dir, label_path)
             out_label_path = os.path.join(processed_annotation_dir, label_path)
-            cv2.imwrite(out_image_path.replace('.png', '.jpg'), image)
+            cv2.imwrite(out_image_path.replace(".png", ".jpg"), image)
             cv2.imwrite(out_label_path, label)
 
     def sugarbeet_weed_segmentation(self, dataset_name):
         # Get all of the relevant data
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        train_dir = os.path.join(dataset_dir, 'train')
+        train_dir = os.path.join(dataset_dir, "train")
         train_images = sorted(get_file_list(train_dir))
-        annotation_dir = os.path.join(dataset_dir, 'trainannot')  # noqa
+        annotation_dir = os.path.join(dataset_dir, "trainannot")  # noqa
         annotation_images = sorted(get_file_list(annotation_dir))
 
         # Move the images to the new directory
         move_segmentation_dataset(
-            self.data_processed_dir, dataset_name, train_images,
-            annotation_images, train_dir, annotation_dir)
+            self.data_processed_dir,
+            dataset_name,
+            train_images,
+            annotation_images,
+            train_dir,
+            annotation_dir,
+        )
 
     def carrot_weeds_germany(self, dataset_name):
         # Get all of the relevant data.
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        train_dir = os.path.join(dataset_dir, 'images')
+        train_dir = os.path.join(dataset_dir, "images")
         train_images = sorted(get_file_list(train_dir))
-        annotation_dir = os.path.join(dataset_dir, 'annotations')
-        annotation_images = sorted(get_file_list(annotation_dir, ext = 'png'))
+        annotation_dir = os.path.join(dataset_dir, "annotations")
+        annotation_images = sorted(get_file_list(annotation_dir, ext="png"))
 
         # Move the images to the new directory.
         def _annotation_preprocess_fn(annotation_path, out_path):
             an_img = cv2.cvtColor(cv2.imread(annotation_path), cv2.COLOR_BGR2RGB)
             crop, weed = (0, 255, 0), (255, 0, 0)
-            out_annotation = np.zeros(shape = an_img.shape[:-1])
-            crop_indices = np.stack(np.where(np.all(an_img == crop, axis = -1))).T
-            weed_indices = np.stack(np.where(np.all(an_img == weed, axis = -1))).T
+            out_annotation = np.zeros(shape=an_img.shape[:-1])
+            crop_indices = np.stack(np.where(np.all(an_img == crop, axis=-1))).T
+            weed_indices = np.stack(np.where(np.all(an_img == weed, axis=-1))).T
             for indxs in crop_indices:
                 out_annotation[indxs[0]][indxs[1]] = 1
             for indxs in weed_indices:
@@ -626,17 +630,21 @@ def _annotation_preprocess_fn(annotation_path, out_path):
             return cv2.imwrite(out_path, out_annotation.astype(np.int8))
 
         move_segmentation_dataset(
-            self.data_processed_dir, dataset_name, train_images,
-            annotation_images, train_dir, annotation_dir,
-            annotation_preprocess_fn = _annotation_preprocess_fn
+            self.data_processed_dir,
+            dataset_name,
+            train_images,
+            annotation_images,
+            train_dir,
+            annotation_dir,
+            annotation_preprocess_fn=_annotation_preprocess_fn,
         )
 
     def apple_segmentation_minnesota(self, dataset_name):
         # Get all of the relevant data.
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        train_dir = os.path.join(dataset_dir, 'train', 'images')
+        train_dir = os.path.join(dataset_dir, "train", "images")
         train_images = sorted(get_file_list(train_dir))
-        masks_dir = os.path.join(dataset_dir, 'train', 'masks')
+        masks_dir = os.path.join(dataset_dir, "train", "masks")
         mask_images = sorted(get_file_list(masks_dir))
 
         # Move the images to the new directory.
@@ -656,41 +664,44 @@ def _annotation_preprocess_fn(annotation_path, out_path):
             return cv2.imwrite(out_path, mask)
 
         move_segmentation_dataset(
-            self.data_processed_dir, dataset_name, train_images,
-            mask_images, train_dir, masks_dir,
-            annotation_preprocess_fn = _annotation_preprocess_fn
+            self.data_processed_dir,
+            dataset_name,
+            train_images,
+            mask_images,
+            train_dir,
+            masks_dir,
+            annotation_preprocess_fn=_annotation_preprocess_fn,
         )
 
-    def rice_seedling_segmentation(self, dataset_name, fix = False):
+    def rice_seedling_segmentation(self, dataset_name, fix=False):
         # Re-mapping labels to remove the `Background` class.
         if fix:
             data_dir = os.path.join(self.data_original_dir, dataset_name)
-            annotations = sorted([
-                os.path.join(data_dir, 'annotations', i)
-                for i in os.listdir(os.path.join(data_dir, 'annotations'))])
-            os.makedirs(os.path.join(data_dir, 'new_annotations'))
+            annotations = sorted(
+                [os.path.join(data_dir, "annotations", i) for i in os.listdir(os.path.join(data_dir, "annotations"))]
+            )
+            os.makedirs(os.path.join(data_dir, "new_annotations"))
 
             # Create the remap.
             for annotation in tqdm(annotations):
                 a = cv2.imread(annotation)
                 a[a == 2] = 0
                 a[a == 3] = 2
-                cv2.imwrite(os.path.join(
-                    data_dir, 'new_annotations', os.path.basename(annotation)), a)
+                cv2.imwrite(
+                    os.path.join(data_dir, "new_annotations", os.path.basename(annotation)),
+                    a,
+                )
             return
 
         # Get all of the relevant data.
         data_dir = os.path.join(self.data_original_dir, dataset_name)
-        images = sorted(glob.glob(os.path.join(data_dir, 'image_*.jpg')))
-        labels = sorted(glob.glob(os.path.join(data_dir, 'Label_*.png')))
+        images = sorted(glob.glob(os.path.join(data_dir, "image_*.jpg")))
+        labels = sorted(glob.glob(os.path.join(data_dir, "Label_*.png")))
         images = [os.path.basename(p) for p in images]
         labels = [os.path.basename(p) for p in labels]
 
         # Move the images to the new directory.
-        move_segmentation_dataset(
-            self.data_processed_dir, dataset_name,
-            images, labels, data_dir, data_dir
-        )
+        move_segmentation_dataset(self.data_processed_dir, dataset_name, images, labels, data_dir, data_dir)
 
     def sugarcane_damage_usa(self, dataset_name):
         pass
@@ -704,40 +715,38 @@ def plant_village_classification(self, dataset_name):
     def autonomous_greenhouse_regression(self, dataset_name):
         # Get all of the data paths.
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        image_dir = os.path.join(dataset_dir, 'RGBImages')
-        depth_dir = os.path.join(dataset_dir, 'DepthImages')
-        with open(os.path.join(dataset_dir, 'dataset.json'), 'r') as f:
+        image_dir = os.path.join(dataset_dir, "RGBImages")
+        depth_dir = os.path.join(dataset_dir, "DepthImages")
+        with open(os.path.join(dataset_dir, "dataset.json"), "r") as f:
             contents = json.load(f)
 
         # Construct the output annotation JSON file.
         out = []
-        for sample in contents['labels'].values():
-            out.append({
-                'image': sample['rgb_image_path'],
-                'depth_image': sample['depth_image_path'],
-                'outputs': {
-                    'regression': sample['regression_outputs'],
-                    'classification': sample['classification_outputs']['Variety']
+        for sample in contents["labels"].values():
+            out.append(
+                {
+                    "image": sample["rgb_image_path"],
+                    "depth_image": sample["depth_image_path"],
+                    "outputs": {
+                        "regression": sample["regression_outputs"],
+                        "classification": sample["classification_outputs"]["Variety"],
+                    },
                 }
-            })
+            )
 
         # Copy the images over.
         out_dir = os.path.join(self.data_processed_dir, dataset_name)
-        out_image_dir = os.path.join(out_dir, 'images')
-        os.makedirs(out_image_dir, exist_ok = True)
-        out_depth_dir = os.path.join(out_dir, 'depth_images')
-        os.makedirs(out_depth_dir, exist_ok = True)
-        for image in tqdm(os.listdir(image_dir),
-                          desc = "Moving Images", file = sys.stdout):
-            shutil.copyfile(os.path.join(image_dir, image),
-                            os.path.join(out_image_dir, image))
-        for depth in tqdm(os.listdir(depth_dir),
-                          desc = "Moving Depth Images", file = sys.stdout):
-            shutil.copyfile(os.path.join(depth_dir, depth),
-                            os.path.join(out_depth_dir, depth))
+        out_image_dir = os.path.join(out_dir, "images")
+        os.makedirs(out_image_dir, exist_ok=True)
+        out_depth_dir = os.path.join(out_dir, "depth_images")
+        os.makedirs(out_depth_dir, exist_ok=True)
+        for image in tqdm(os.listdir(image_dir), desc="Moving Images", file=sys.stdout):
+            shutil.copyfile(os.path.join(image_dir, image), os.path.join(out_image_dir, image))
+        for depth in tqdm(os.listdir(depth_dir), desc="Moving Depth Images", file=sys.stdout):
+            shutil.copyfile(os.path.join(depth_dir, depth), os.path.join(out_depth_dir, depth))
 
         # Save the annotation file.
-        with open(os.path.join(out_dir, 'annotations.json'), 'w') as f:
+        with open(os.path.join(out_dir, "annotations.json"), "w") as f:
             json.dump(out, f)
 
     def guava_disease_pakistan(self, dataset_name):
@@ -746,17 +755,15 @@ def guava_disease_pakistan(self, dataset_name):
         classes = os.listdir(dataset_dir)
         all_images = []
         for cls in classes:
-            all_images.extend([
-                os.path.join(dataset_dir, cls, i)
-                for i in os.listdir(os.path.join(dataset_dir, cls))])
+            all_images.extend([os.path.join(dataset_dir, cls, i) for i in os.listdir(os.path.join(dataset_dir, cls))])
 
         # Resize all of the images.
         out_dir = os.path.join(self.data_processed_dir, dataset_name)
-        os.makedirs(out_dir, exist_ok = True)
+        os.makedirs(out_dir, exist_ok=True)
         for cls in classes:
-            os.makedirs(os.path.join(out_dir, cls), exist_ok = True)
-        for image in tqdm(all_images, 'Resizing Images'):
-            out_image = image.replace('/original/', '/processed/')
+            os.makedirs(os.path.join(out_dir, cls), exist_ok=True)
+        for image in tqdm(all_images, "Resizing Images"):
+            out_image = image.replace("/original/", "/processed/")
             im = cv2.imread(image, cv2.IMREAD_UNCHANGED)
             im = cv2.resize(im, (im.shape[1] // 5, im.shape[0] // 5), cv2.INTER_LINEAR)
             cv2.imwrite(out_image, im)
@@ -769,7 +776,7 @@ def apple_detection_spain(self, dataset_name):
         datasource_file = os.path.join(os.path.dirname(__file__), "../_assets/public_datasources.json")
         with open(datasource_file) as f:
             data = json.load(f)
-            category_info = data[dataset_name]['crop_types']
+            category_info = data[dataset_name]["crop_types"]
             labels_str = []
             labels_ids = []
             for info in category_info:
@@ -788,12 +795,12 @@ def apple_detection_spain(self, dataset_name):
         img_files = [x.replace(".xml", "hr.jpg").replace("square_annotations1", "images") for x in anno_files]
 
         # Process annotation files
-        save_dir_anno = os.path.join(self.data_processed_dir, dataset_name, 'annotations')
+        save_dir_anno = os.path.join(self.data_processed_dir, dataset_name, "annotations")
         create_dir(save_dir_anno)
-        output_json_file = os.path.join(save_dir_anno, 'instances.json')
+        output_json_file = os.path.join(save_dir_anno, "instances.json")
 
         # Process image files
-        output_img_path = os.path.join(self.data_processed_dir, dataset_name, 'images')
+        output_img_path = os.path.join(self.data_processed_dir, dataset_name, "images")
         create_dir(output_img_path)
 
         general_info = {
@@ -802,46 +809,44 @@ def apple_detection_spain(self, dataset_name):
             "version": "1.0",
             "year": 2018,
             "contributor": "Gené-Mola J, Vilaplana V, Rosell-Polo JR, Morros JR, Ruiz-Hidalgo J, Gregorio E",
-            "date_created": "2018/10/19"
+            "date_created": "2018/10/19",
         }
 
         convert_xmls_to_cocojson(
             general_info,
-            annotation_paths = anno_files,
-            img_paths = img_files,
-            label2id = label2id,
-            name_converter = name_converter,
-            output_jsonpath = output_json_file,
-            output_imgpath = output_img_path,
-            extract_num_from_imgid = True
+            annotation_paths=anno_files,
+            img_paths=img_files,
+            label2id=label2id,
+            name_converter=name_converter,
+            output_jsonpath=output_json_file,
+            output_imgpath=output_img_path,
+            extract_num_from_imgid=True,
         )
 
     def apple_detection_drone_brazil(self, dataset_name):
         # Get the data directory and rename it if necessary.
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
         if not os.path.exists(dataset_dir):
-            fallback = os.path.join(self.data_original_dir,
-                                    'thsant-add256-68d2f88')  # noqa
+            fallback = os.path.join(self.data_original_dir, "thsant-add256-68d2f88")  # noqa
             if os.path.exists(fallback):
                 os.rename(fallback, dataset_dir)
 
         # Get all of the images which have valid annotations.
-        with open(os.path.join(dataset_dir, 'all.json'), 'r') as f:
+        with open(os.path.join(dataset_dir, "all.json"), "r") as f:
             original_annotations = json.load(f)
-        valid_annotations = {k: v for k, v in
-                             original_annotations.items() if v != []}
+        valid_annotations = {k: v for k, v in original_annotations.items() if v != []}
 
         # Construct the `images` part of the COCO JSON.
         image_coco = []
         image_id_map = {}
-        image_dir = os.path.join(dataset_dir, 'images')
+        image_dir = os.path.join(dataset_dir, "images")
         for idx, image_name in tqdm(
-                enumerate(valid_annotations.keys()),
-                desc = "Parsing Images", total = len(valid_annotations)):
+            enumerate(valid_annotations.keys()),
+            desc="Parsing Images",
+            total=len(valid_annotations),
+        ):
             height, width = cv2.imread(os.path.join(image_dir, image_name)).shape[:2]
-            image_coco.append(
-                {'file_name': image_name, 'height': height,
-                 'width': width, 'id': idx})
+            image_coco.append({"file_name": image_name, "height": height, "width": width, "id": idx})
             image_id_map[image_name] = idx
 
         # Construct the `annotations` part of the COCO JSON.
@@ -851,46 +856,55 @@ def apple_detection_drone_brazil(self, dataset_name):
             for annotation in annotation_list:
                 # Coordinates are in form (center_x, center_y, radius). We convert
                 # these to (top left x, top left y, width, height)
-                x_c, y_c, r = annotation['cx'], annotation['cy'], annotation['r']
+                x_c, y_c, r = annotation["cx"], annotation["cy"], annotation["r"]
                 x, y = x_c - r, y_c - r
                 w = h = r * 2
-                annotation_coco.append({
-                    'area': w * h, 'iscrowd': 0, 'bbox': [x, y, w, h],
-                    'category_id': 1, 'ignore': 0, 'segmentation': 0,
-                    'image_id': image_id_map[image_name], 'id': annotation_idx})
+                annotation_coco.append(
+                    {
+                        "area": w * h,
+                        "iscrowd": 0,
+                        "bbox": [x, y, w, h],
+                        "category_id": 1,
+                        "ignore": 0,
+                        "segmentation": 0,
+                        "image_id": image_id_map[image_name],
+                        "id": annotation_idx,
+                    }
+                )
                 annotation_idx += 1
 
         # Set up the annotation dictionary.
-        category_info = [{'supercategory': 'none', 'id': 1, 'name': 'apple'}]
+        category_info = [{"supercategory": "none", "id": 1, "name": "apple"}]
         all_annotation_data = {
-            "images": image_coco, "type": "instances",
-            "annotations": annotation_coco, "categories": category_info,
+            "images": image_coco,
+            "type": "instances",
+            "annotations": annotation_coco,
+            "categories": category_info,
             "info": {
                 "description": "apple detection dataset with drone imagery",
                 "url": "https://github.com/thsant/add256/tree/zenodo-1.0",
                 "version": "1.0",
                 "year": 2021,
                 "contributor": "Thiago T. Santos and Luciano Gebler",
-                "date_created": "2021/10/2021"
-            }
+                "date_created": "2021/10/2021",
+            },
         }
 
         # Recreate the dataset and zip it
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        processed_img_dir = os.path.join(processed_dir, 'images')
+        processed_img_dir = os.path.join(processed_dir, "images")
         if os.path.exists(processed_dir):
             shutil.rmtree(processed_dir)
-        os.makedirs(processed_dir, exist_ok = True)
-        os.makedirs(processed_img_dir, exist_ok = True)
-        for path in tqdm(valid_annotations.keys(), desc = "Moving Images"):
+        os.makedirs(processed_dir, exist_ok=True)
+        os.makedirs(processed_img_dir, exist_ok=True)
+        for path in tqdm(valid_annotations.keys(), desc="Moving Images"):
             full_path = os.path.join(image_dir, path)
-            shutil.copyfile(full_path, os.path.join(
-                processed_img_dir, os.path.basename(path)))
-        with open(os.path.join(processed_dir, 'annotations.json'), 'w') as f:
+            shutil.copyfile(full_path, os.path.join(processed_img_dir, os.path.basename(path)))
+        with open(os.path.join(processed_dir, "annotations.json"), "w") as f:
             json.dump(all_annotation_data, f)
 
     def plant_doc_classification(self, dataset_name):
-        category_info = self.data_sources[dataset_name]['classes']
+        category_info = self.data_sources[dataset_name]["classes"]
 
         # paths to original files
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
@@ -924,32 +938,34 @@ def plant_doc_classification(self, dataset_name):
     def wheat_head_counting(self, dataset_name):
         label2id = {"Wheat Head": 1}
         dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-        anno_files = [os.path.join(dataset_dir, 'competition_train.csv'), os.path.join(dataset_dir, 'competition_test.csv'), os.path.join(dataset_dir, 'competition_val.csv')]
-        
+        anno_files = [
+            os.path.join(dataset_dir, "competition_train.csv"),
+            os.path.join(dataset_dir, "competition_test.csv"),
+            os.path.join(dataset_dir, "competition_val.csv"),
+        ]
+
         annotations = []
         for anno_file in anno_files:
-          with open(anno_file, 'r') as file:
-              reader = csv.reader(file)
-              for row in reader:
-                  img_path = os.path.join(dataset_dir, "images", row[0])
-                  anno = [img_path]
-                  bboxs = row[1].split(";")
-                  anno.append(len(bboxs))
-                  for bbox in bboxs:
-                      if bbox != "no_box":
-                        bbox = bbox.split(" ")
-                        bbox.append("1")
-                        anno.append(bbox)
-                  annotations.append(anno)
+            with open(anno_file, "r") as file:
+                reader = csv.reader(file)
+                for row in reader:
+                    img_path = os.path.join(dataset_dir, "images", row[0])
+                    anno = [img_path]
+                    bboxs = row[1].split(";")
+                    anno.append(len(bboxs))
+                    for bbox in bboxs:
+                        if bbox != "no_box":
+                            bbox = bbox.split(" ")
+                            bbox.append("1")
+                            anno.append(bbox)
+                    annotations.append(anno)
 
         # Define path to processed annotation files
-        output_json_file = os.path.join(
-            self.data_processed_dir, dataset_name, 'annotations.json')
+        output_json_file = os.path.join(self.data_processed_dir, dataset_name, "annotations.json")
 
         # Create directory for processed image files
-        output_img_path = os.path.join(
-            self.data_processed_dir, dataset_name, 'images')
-        create_dir(output_img_path) 
+        output_img_path = os.path.join(self.data_processed_dir, dataset_name, "images")
+        create_dir(output_img_path)
 
         general_info = {
             "description": "Global Wheat Head Detection (GWHD) dataset",
@@ -957,105 +973,123 @@ def wheat_head_counting(self, dataset_name):
             "version": "1.0",
             "year": 2021,
             "contributor": "David, Etienne and Madec, Simon and Sadeghi-Tehran, Pouria and Aasen, Helge and Zheng, Bangyou and Liu, Shouyang and Kirchgessner, Norbert and Ishikawa, Goro and Nagasawa, Koichi and Badhon, Minhajul A and others",
-            "date_created": "2021/7/12"
+            "date_created": "2021/7/12",
         }
 
         convert_bbox_to_coco(
-            annotations, label2id, output_json_file,
-            output_img_path, general_info, resize=512/1024)
+            annotations,
+            label2id,
+            output_json_file,
+            output_img_path,
+            general_info,
+            resize=512 / 1024,
+        )
 
     def peachpear_flower_segmentation(self, dataset_name):
-      # Create processed directories 
-      processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-      os.makedirs(processed_dir, exist_ok = True)
-      processed_image_dir = os.path.join(processed_dir, 'images')
-      os.makedirs(processed_image_dir, exist_ok = True)
-      processed_annotation_dir = os.path.join(processed_dir, 'annotations')
-      os.makedirs(processed_annotation_dir, exist_ok = True)
-
-      dataset_dir = os.path.join(self.data_original_dir, dataset_name)
-
-      # Get image files
-      img_dirs = ["Peach", "Pear"]
-      img_paths = []
-      for img_dir in img_dirs:
-        img_paths += [os.path.join(dataset_dir, img_dir, file_name) for file_name in get_file_list(os.path.join(dataset_dir, img_dir))]
-
-      # Save all images as jpg in processed directory
-      for img_path in img_paths:
-        processed_path = os.path.join(processed_image_dir, img_path.split('/')[-1].replace('.bmp', '.jpg'))
-        img = cv2.imread(img_path)
-        cv2.imwrite(processed_path, img)
-
-      # Get annotation files
-      anno_dirs = ["PeachLabels", "PearLabels"]
-      anno_paths = []
-      for anno_dir in anno_dirs:
-        anno_paths += [os.path.join(dataset_dir, anno_dir, file_name) for file_name in get_file_list(os.path.join(dataset_dir, anno_dir))]
-
-      # Transform mask and save to processed directory
-      for anno_path in anno_paths:
-        img = cv2.imread(anno_path, cv2.IMREAD_GRAYSCALE)
-        img = np.where(img[:] == 255, 1, 0)
-        processed_path = os.path.join(processed_annotation_dir, anno_path.split('/')[-1])
-        cv2.imwrite(processed_path, img)
+        # Create processed directories
+        processed_dir = os.path.join(self.data_processed_dir, dataset_name)
+        os.makedirs(processed_dir, exist_ok=True)
+        processed_image_dir = os.path.join(processed_dir, "images")
+        os.makedirs(processed_image_dir, exist_ok=True)
+        processed_annotation_dir = os.path.join(processed_dir, "annotations")
+        os.makedirs(processed_annotation_dir, exist_ok=True)
+
+        dataset_dir = os.path.join(self.data_original_dir, dataset_name)
+
+        # Get image files
+        img_dirs = ["Peach", "Pear"]
+        img_paths = []
+        for img_dir in img_dirs:
+            img_paths += [
+                os.path.join(dataset_dir, img_dir, file_name)
+                for file_name in get_file_list(os.path.join(dataset_dir, img_dir))
+            ]
+
+        # Save all images as jpg in processed directory
+        for img_path in img_paths:
+            processed_path = os.path.join(processed_image_dir, img_path.split("/")[-1].replace(".bmp", ".jpg"))
+            img = cv2.imread(img_path)
+            cv2.imwrite(processed_path, img)
+
+        # Get annotation files
+        anno_dirs = ["PeachLabels", "PearLabels"]
+        anno_paths = []
+        for anno_dir in anno_dirs:
+            anno_paths += [
+                os.path.join(dataset_dir, anno_dir, file_name)
+                for file_name in get_file_list(os.path.join(dataset_dir, anno_dir))
+            ]
+
+        # Transform mask and save to processed directory
+        for anno_path in anno_paths:
+            img = cv2.imread(anno_path, cv2.IMREAD_GRAYSCALE)
+            img = np.where(img[:] == 255, 1, 0)
+            processed_path = os.path.join(processed_annotation_dir, anno_path.split("/")[-1])
+            cv2.imwrite(processed_path, img)
 
     def ghai_romaine_detection(self, dataset_name):
         # Create processed directories
         original_dir = os.path.join(self.data_original_dir, dataset_name)
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        processed_image_dir = os.path.join(processed_dir, 'images')
-        os.makedirs(processed_image_dir, exist_ok = True)
+        processed_image_dir = os.path.join(processed_dir, "images")
+        os.makedirs(processed_image_dir, exist_ok=True)
 
         # Move images
-        for image in glob.glob(os.path.join(original_dir, '*.jpg')):
+        for image in glob.glob(os.path.join(original_dir, "*.jpg")):
             shutil.move(image, processed_image_dir)
-        shutil.move(os.path.join(original_dir, 'coco.json'),
-                    os.path.join(processed_dir, 'annotations.json'))
+        shutil.move(
+            os.path.join(original_dir, "coco.json"),
+            os.path.join(processed_dir, "annotations.json"),
+        )
 
     def ghai_green_cabbage_detection(self, dataset_name):
         # Create processed directories
         original_dir = os.path.join(self.data_original_dir, dataset_name)
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        processed_image_dir = os.path.join(processed_dir, 'images')
-        os.makedirs(processed_image_dir, exist_ok = True)
+        processed_image_dir = os.path.join(processed_dir, "images")
+        os.makedirs(processed_image_dir, exist_ok=True)
 
         # Move images
-        for image in glob.glob(os.path.join(original_dir, '*.jpg')):
+        for image in glob.glob(os.path.join(original_dir, "*.jpg")):
             shutil.move(image, processed_image_dir)
-        shutil.move(os.path.join(original_dir, 'coco.json'),
-                    os.path.join(processed_dir, 'annotations.json'))
+        shutil.move(
+            os.path.join(original_dir, "coco.json"),
+            os.path.join(processed_dir, "annotations.json"),
+        )
 
     def ghai_iceberg_lettuce_detection(self, dataset_name):
         # Create processed directories
         original_dir = os.path.join(self.data_original_dir, dataset_name)
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        processed_image_dir = os.path.join(processed_dir, 'images')
-        os.makedirs(processed_image_dir, exist_ok = True)
+        processed_image_dir = os.path.join(processed_dir, "images")
+        os.makedirs(processed_image_dir, exist_ok=True)
 
         # Move images
-        for image in glob.glob(os.path.join(original_dir, '*.jpg')):
+        for image in glob.glob(os.path.join(original_dir, "*.jpg")):
             shutil.move(image, processed_image_dir)
-        shutil.move(os.path.join(original_dir, 'coco.json'),
-                    os.path.join(processed_dir, 'annotations.json'))
+        shutil.move(
+            os.path.join(original_dir, "coco.json"),
+            os.path.join(processed_dir, "annotations.json"),
+        )
 
     def riseholme_strawberry_classification_2021(self, dataset_name):
         # Create processed data directory.
-        original_dir = os.path.join(
-            self.data_original_dir, 'Riseholme-2021-main', 'Data')
+        original_dir = os.path.join(self.data_original_dir, "Riseholme-2021-main", "Data")
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
 
         # Load all of the individual images and keep a mapping to their corresponding directory.
         images = {
-            'anomalous': get_file_list(os.path.join(original_dir, 'Anomalous')),
-            **{dir_.lower(): get_file_list(os.path.join(original_dir, 'Normal', dir_))
-               for dir_ in os.listdir(os.path.join(original_dir, 'Normal'))}
+            "anomalous": get_file_list(os.path.join(original_dir, "Anomalous")),
+            **{
+                dir_.lower(): get_file_list(os.path.join(original_dir, "Normal", dir_))
+                for dir_ in os.listdir(os.path.join(original_dir, "Normal"))
+            },
         }
 
         # Create the output file structure.
         for class_name, image_set in images.items():
             class_dir = os.path.join(processed_dir, class_name)
-            os.makedirs(class_dir, exist_ok = True)
+            os.makedirs(class_dir, exist_ok=True)
             for file in image_set:
                 shutil.copyfile(file, os.path.join(class_dir, os.path.basename(file)))
 
@@ -1063,70 +1097,76 @@ def ghai_broccoli_detection(self, dataset_name):
         # Create processed directories
         original_dir = os.path.join(self.data_original_dir, dataset_name)
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        processed_image_dir = os.path.join(processed_dir, 'images')
-        os.makedirs(processed_image_dir, exist_ok = True)
+        processed_image_dir = os.path.join(processed_dir, "images")
+        os.makedirs(processed_image_dir, exist_ok=True)
 
         # Move images
-        for image in tqdm(glob.glob(os.path.join(original_dir, '*.jpg'))):
+        for image in tqdm(glob.glob(os.path.join(original_dir, "*.jpg"))):
             shutil.move(image, processed_image_dir)
-        shutil.move(os.path.join(original_dir, 'coco.json'),
-                    os.path.join(processed_dir, 'annotations.json'))
+        shutil.move(
+            os.path.join(original_dir, "coco.json"),
+            os.path.join(processed_dir, "annotations.json"),
+        )
 
     def ghai_strawberry_fruit_detection(self, dataset_name):
         # Create processed directories
         original_dir = os.path.join(self.data_original_dir, dataset_name)
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        processed_image_dir = os.path.join(processed_dir, 'images')
-        os.makedirs(processed_image_dir, exist_ok = True)
+        processed_image_dir = os.path.join(processed_dir, "images")
+        os.makedirs(processed_image_dir, exist_ok=True)
 
         # Move images
-        for image in tqdm(glob.glob(os.path.join(original_dir, '*.jpg'))):
+        for image in tqdm(glob.glob(os.path.join(original_dir, "*.jpg"))):
             shutil.move(image, processed_image_dir)
-        shutil.move(os.path.join(original_dir, 'coco.json'),
-                    os.path.join(processed_dir, 'annotations.json'))
+        shutil.move(
+            os.path.join(original_dir, "coco.json"),
+            os.path.join(processed_dir, "annotations.json"),
+        )
 
     def vegann_multicrop_presence_segmentation(self, dataset_name):
         # Create processed directories
         original_dir = os.path.join(self.data_original_dir, dataset_name)
         processed_dir = os.path.join(self.data_processed_dir, dataset_name)
-        processed_image_dir = os.path.join(processed_dir, 'images')
-        os.makedirs(processed_image_dir, exist_ok = True)
-        processed_annotation_dir = os.path.join(processed_dir, 'annotations')
-        os.makedirs(processed_annotation_dir, exist_ok = True)
+        processed_image_dir = os.path.join(processed_dir, "images")
+        os.makedirs(processed_image_dir, exist_ok=True)
+        processed_annotation_dir = os.path.join(processed_dir, "annotations")
+        os.makedirs(processed_annotation_dir, exist_ok=True)
 
         # Move images
-        for image in tqdm(glob.glob(os.path.join(original_dir, 'images', '*.png'))):
+        for image in tqdm(glob.glob(os.path.join(original_dir, "images", "*.png"))):
             shutil.copyfile(image, os.path.join(processed_image_dir, os.path.basename(image)))
 
         # Read annotations
-        for annotation_file in tqdm(glob.glob(os.path.join(original_dir, 'annotations', '*.png'))):
+        for annotation_file in tqdm(glob.glob(os.path.join(original_dir, "annotations", "*.png"))):
             annotation = cv2.imread(annotation_file, cv2.IMREAD_UNCHANGED)
             annotation = np.where(annotation == 255, 1, 0)
-            cv2.imwrite(os.path.join(processed_annotation_dir,
-                                     os.path.basename(annotation_file)), annotation)
+            cv2.imwrite(
+                os.path.join(processed_annotation_dir, os.path.basename(annotation_file)),
+                annotation,
+            )
 
         # Read the CSV file containing the splits
-        split_csv = pd.read_csv(os.path.join(original_dir, 'VegAnn_dataset.csv'), sep=';')
+        split_csv = pd.read_csv(os.path.join(original_dir, "VegAnn_dataset.csv"), sep=";")
 
         # Get the `Name` and `TVT-split{n}` columns for each n, and save the splits to a folder
-        splits_folder = os.path.join(processed_dir, '.splits')
-        os.makedirs(splits_folder, exist_ok = True)
-        column_pairs = [['Name', f'TVT-split{i}'] for i in range(1, 5 + 1)]
+        splits_folder = os.path.join(processed_dir, ".splits")
+        os.makedirs(splits_folder, exist_ok=True)
+        column_pairs = [["Name", f"TVT-split{i}"] for i in range(1, 5 + 1)]
 
         splits = {}
         for column_pair in column_pairs:
             columns = split_csv[column_pair]
-            train_images = columns[columns[column_pair[1]] == 'Training']['Name']
-            test_images = columns[columns[column_pair[1]] == 'Test']['Name']
+            train_images = columns[columns[column_pair[1]] == "Training"]["Name"]
+            test_images = columns[columns[column_pair[1]] == "Test"]["Name"]
             splits[column_pair[1]] = {
-                'train': {os.path.join('images', i): os.path.join('annotations', i) for i in train_images},
-                'val': {},
-                'test': {os.path.join('images', i): os.path.join('annotations', i) for i in test_images}
+                "train": {os.path.join("images", i): os.path.join("annotations", i) for i in train_images},
+                "val": {},
+                "test": {os.path.join("images", i): os.path.join("annotations", i) for i in test_images},
             }
 
         # Save each split to a JSON file
         for split_name, split in splits.items():
-            with open(os.path.join(splits_folder, f'{split_name}.json'), 'w') as f:
+            with open(os.path.join(splits_folder, f"{split_name}.json"), "w") as f:
                 json.dump(split, f)
 
             # Check if the directories exist
@@ -1140,9 +1180,9 @@ def vegann_multicrop_presence_segmentation(self, dataset_name):
 
             # Process all images and their corresponding YOLO labels
             for img_file in tqdm(os.listdir(images_dir), desc=f"Processing images for {folder}"):
-                if img_file.endswith(('jpg', 'jpeg', 'png')):
+                if img_file.endswith(("jpg", "jpeg", "png")):
                     image_path = os.path.join(images_dir, img_file)
-                    label_file = img_file.replace('.jpg', '.txt').replace('.jpeg', '.txt').replace('.png', '.txt')
+                    label_file = img_file.replace(".jpg", ".txt").replace(".jpeg", ".txt").replace(".png", ".txt")
                     label_path = os.path.join(labels_dir, label_file)
 
                     # Read the image to get its dimensions
@@ -1157,13 +1197,13 @@ def vegann_multicrop_presence_segmentation(self, dataset_name):
                         "file_name": f"{folder}/{img_file}",  # Include folder name in file path
                         "height": img_height,
                         "width": img_width,
-                        "id": image_id
+                        "id": image_id,
                     }
-                    coco_annotation['images'].append(image_info)
+                    coco_annotation["images"].append(image_info)
 
                     # Read the YOLO label file and convert to COCO format
                     if os.path.exists(label_path):
-                        with open(label_path, 'r') as f:
+                        with open(label_path, "r") as f:
                             lines = f.readlines()
 
                         # Prepare annotations in COCO format
@@ -1173,7 +1213,14 @@ def vegann_multicrop_presence_segmentation(self, dataset_name):
                             x_center, y_center, bbox_width, bbox_height = map(float, elements[1:])
 
                             # Convert to COCO format bounding box
-                            bbox = yolo_to_coco_bbox(x_center, y_center, bbox_width, bbox_height, img_width, img_height)
+                            bbox = yolo_to_coco_bbox(
+                                x_center,
+                                y_center,
+                                bbox_width,
+                                bbox_height,
+                                img_width,
+                                img_height,
+                            )
 
                             annotation = {
                                 "image_id": image_id,  # Reference to the image ID
@@ -1182,9 +1229,9 @@ def vegann_multicrop_presence_segmentation(self, dataset_name):
                                 "id": annotation_id,  # Unique annotation ID
                                 "area": bbox[2] * bbox[3],  # width * height
                                 "iscrowd": 0,
-                                "segmentation": []
+                                "segmentation": [],
                             }
-                            coco_annotation['annotations'].append(annotation)
+                            coco_annotation["annotations"].append(annotation)
                             annotation_id += 1
                     else:
                         print(f"Warning: No label file found for {img_file}")
@@ -1196,11 +1243,12 @@ def vegann_multicrop_presence_segmentation(self, dataset_name):
                     image_id += 1
 
         # Save the final COCO annotations to the correct path inside the processed folder
-        output_json_file = os.path.join(output_base_dir, 'annotations.json')
-        with open(output_json_file, 'w') as json_file:
+        output_json_file = os.path.join(output_base_dir, "annotations.json")
+        with open(output_json_file, "w") as json_file:
             json.dump(coco_annotation, json_file, indent=4)
 
         print(f"COCO annotations saved to {output_json_file}")
+
     def plant_doc_detection(self, dataset_name):
         # Resize the dataset (if necessary)
         resize = 1.0
@@ -1209,7 +1257,7 @@ def plant_doc_detection(self, dataset_name):
         datasource_file = os.path.join(os.path.dirname(__file__), "../_assets/public_datasources.json")
         with open(datasource_file) as f:
             data = json.load(f)
-            category_info = data[dataset_name]['classes']  # This will give us the class information
+            category_info = data[dataset_name]["classes"]  # This will give us the class information
             labels_str = []
             labels_ids = []
             for info in category_info:
@@ -1235,7 +1283,7 @@ def plant_doc_detection(self, dataset_name):
         # output_json_file = os.path.join(save_dir_anno, 'instances.json')
 
         # Process image files
-        output_img_path = os.path.join(self.data_processed_dir, dataset_name, 'images')
+        output_img_path = os.path.join(self.data_processed_dir, dataset_name, "images")
         create_dir(output_img_path)
 
         # General information for the COCO JSON format
@@ -1245,11 +1293,11 @@ def plant_doc_detection(self, dataset_name):
             "version": "1.0",
             "year": 2024,
             "contributor": "PlantDoc",
-            "date_created": "2024/10/17"
+            "date_created": "2024/10/17",
         }
 
         # Save the COCO JSON file directly in the processed directory
-        output_json_file = os.path.join(self.data_processed_dir, dataset_name, 'annotations.json')
+        output_json_file = os.path.join(self.data_processed_dir, dataset_name, "annotations.json")
 
         # Convert the XML annotations to COCO format using your existing function
         convert_xmls_to_cocojson(
@@ -1260,7 +1308,7 @@ def plant_doc_detection(self, dataset_name):
             name_converter=name_converter,
             output_jsonpath=output_json_file,
             output_imgpath=output_img_path,
-            extract_num_from_imgid=False
+            extract_num_from_imgid=False,
         )
 
         print(f"Preprocessing completed! Annotations saved to {output_json_file}")
@@ -1268,10 +1316,10 @@ def plant_doc_detection(self, dataset_name):
     # def grape_bunch_detection(self, dataset_name):
     #     """Preprocesses your grape dataset (Chardonnay, PinotGris, PinotNoir) from YOLO format to COCO format."""
     #     base_path = os.path.join(self.data_original_dir)
-        
+
     #     # Get all the dataset folders (Chardonnay, PinotGris, PinotNoir)
     #     dataset_folders = ['Chardonnay', 'PinotGris', 'PinotNoir']
-        
+
     #     # Prepare the COCO annotation dictionary
     #     coco_annotation = {
     #         "images": [],
@@ -1450,24 +1498,16 @@ def plant_doc_detection(self, dataset_name):
     #     print(f"COCO annotations saved to {output_json_file}")
 
 
-
-
-
-
-
-
-
-
-
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Initialize program arguments.
     ap = argparse.ArgumentParser()
-    ap.add_argument("--data_dir", type = str, default = '../../data_new',
-                    help = "The directory containing two sub-directories, "
-                           "`original` and `processed`, with the data.")
-    ap.add_argument("--dataset", type = str,
-                    help = "The dataset to process.")
+    ap.add_argument(
+        "--data_dir",
+        type=str,
+        default="../../data_new",
+        help="The directory containing two sub-directories, " "`original` and `processed`, with the data.",
+    )
+    ap.add_argument("--dataset", type=str, help="The dataset to process.")
     args = ap.parse_args()
 
     # Execute the preprocessing.
@@ -1477,5 +1517,3 @@ def plant_doc_detection(self, dataset_name):
     print("Converting dataset")
     # os.chdir(f'{args.data_dir}/processed')
     # os.system(f'zip -r {args.dataset}.zip {args.dataset} -x ".*" -x "__MACOSX"')
-
-
diff --git a/agml/_internal/process_utils.py b/agml/_internal/process_utils.py
index 71ff7981..7af5d6b9 100644
--- a/agml/_internal/process_utils.py
+++ b/agml/_internal/process_utils.py
@@ -34,9 +34,9 @@
 from agml.utils.logging import tqdm
 
 
-def read_txt_file(file_name, delimiter = ' ', header = False):
-    with open(file_name, newline = '\n') as txt_file:
-        txt_reader = csv.reader(txt_file, delimiter = delimiter)
+def read_txt_file(file_name, delimiter=" ", header=False):
+    with open(file_name, newline="\n") as txt_file:
+        txt_reader = csv.reader(txt_file, delimiter=delimiter)
         txt_lines = []
         headline = None
         for idx, line in enumerate(txt_reader):
@@ -48,31 +48,32 @@ def read_txt_file(file_name, delimiter = ' ', header = False):
 
         return txt_lines, headline
 
+
 def get_label2id(labels_str: str) -> Dict[str, int]:
     """id is 1 start"""
     labels_ids = list(range(1, len(labels_str) + 1))
     return dict(zip(labels_str, labels_ids))
 
 
-def get_annpaths(ann_dir_path: str = None,
-                 ann_ids_path: str = None,
-                 ext: str = '',
-                 annpaths_list_path: str = None) -> List[str]:
+def get_annpaths(
+    ann_dir_path: str = None, ann_ids_path: str = None, ext: str = "", annpaths_list_path: str = None
+) -> List[str]:
     # If wanting to use annotation paths list
     if annpaths_list_path is not None:
-        with open(annpaths_list_path, 'r') as f:
+        with open(annpaths_list_path, "r") as f:
             ann_paths = f.read().split()
         return ann_paths
 
     # If wanting to use annotation ids list
-    ext_with_dot = '.' + ext if ext != '' else ''
-    with open(ann_ids_path, 'r') as f:
+    ext_with_dot = "." + ext if ext != "" else ""
+    with open(ann_ids_path, "r") as f:
         ann_ids = f.read().split()
     ann_paths = [os.path.join(ann_dir_path, aid + ext_with_dot) for aid in ann_ids]
     return ann_paths
 
-def get_image_info_from_annoline(annotation_root, idx, resize = 1.0, add_foldername = False):
-    filename = annotation_root[0].split('/')[-1]
+
+def get_image_info_from_annoline(annotation_root, idx, resize=1.0, add_foldername=False):
+    filename = annotation_root[0].split("/")[-1]
     try:
         img = cv2.imread(annotation_root[0])
 
@@ -85,28 +86,30 @@ def get_image_info_from_annoline(annotation_root, idx, resize = 1.0, add_foldern
         height = size[0]
 
         if add_foldername:
-            filename = "{folder}_{img_name}".format(folder = annotation_root[0].split('/')[-2],
-                                                    img_name = annotation_root[0].split('/')[-1])
+            filename = "{folder}_{img_name}".format(
+                folder=annotation_root[0].split("/")[-2], img_name=annotation_root[0].split("/")[-1]
+            )
 
         image_info = {
-            'file_name': filename,
-            'height': height,
-            'width': width,
-            'id': idx  # Use image order
+            "file_name": filename,
+            "height": height,
+            "width": width,
+            "id": idx,  # Use image order
         }
 
     except Exception as e:
         print(e)
-        print("Cannot open {file}".format(file = annotation_root[0]))
+        print("Cannot open {file}".format(file=annotation_root[0]))
         image_info = None
         img = None
 
     return image_info, img
 
-def get_image_info(annotation_root, idx, resize = 1.0, add_foldername = False):
-    path = annotation_root.findtext('path')
+
+def get_image_info(annotation_root, idx, resize=1.0, add_foldername=False):
+    path = annotation_root.findtext("path")
     if path is None or True:
-        filename = annotation_root.findtext('filename')
+        filename = annotation_root.findtext("filename")
     else:
         filename = os.path.basename(path)
 
@@ -122,50 +125,50 @@ def get_image_info(annotation_root, idx, resize = 1.0, add_foldername = False):
         height = size[0]
 
         if add_foldername:
-            filename = "{folder}_{img_name}".format(folder = filename.split('/')[-2],
-                                                    img_name = filename.split('/')[-1])
+            filename = "{folder}_{img_name}".format(folder=filename.split("/")[-2], img_name=filename.split("/")[-1])
 
         image_info = {
-            'file_name': filename.split('/')[-1],
-            'height': height,
-            'width': width,
-            'id': idx  # Use image order
+            "file_name": filename.split("/")[-1],
+            "height": height,
+            "width": width,
+            "id": idx,  # Use image order
         }
 
     except Exception as e:
         print(e)
-        print("Cannot open {file}".format(file = annotation_root[0]))
+        print("Cannot open {file}".format(file=annotation_root[0]))
         image_info = None
         img = None
 
     return image_info, img
 
+
 # Sourced from https://github.com/roboflow-ai/voc2coco.git
-def get_coco_annotation_from_annoline(obj, resize = 1.0):
+def get_coco_annotation_from_annoline(obj, resize=1.0):
     # Try the sub-label first
     category_id = int(obj[4])
     xmin = int(float(obj[0]) * resize)
     ymin = int(float(obj[1]) * resize)
     xmax = int(float(obj[2]) * resize)
     ymax = int(float(obj[3]) * resize)
-    assert xmax > xmin and ymax > ymin, \
-        f"Box size error !: (xmin, ymin, xmax, ymax): {xmin, ymin, xmax, ymax}"
+    assert xmax > xmin and ymax > ymin, f"Box size error !: (xmin, ymin, xmax, ymax): {xmin, ymin, xmax, ymax}"
     o_width = xmax - xmin + 1
     o_height = ymax - ymin + 1
     return {
-        'area': o_width * o_height,
-        'iscrowd': 0,
-        'bbox': [xmin, ymin, o_width, o_height],
-        'category_id': category_id,
-        'ignore': 0,
-        'segmentation': []  # This script is not for segmentation
+        "area": o_width * o_height,
+        "iscrowd": 0,
+        "bbox": [xmin, ymin, o_width, o_height],
+        "category_id": category_id,
+        "ignore": 0,
+        "segmentation": [],  # This script is not for segmentation
     }
 
-def get_coco_annotation_from_obj(obj, label2id, name_converter = None):
+
+def get_coco_annotation_from_obj(obj, label2id, name_converter=None):
     # Try to sub-label first
-    label = obj.findtext('subname')
+    label = obj.findtext("subname")
     if label is None:
-        label = obj.findtext('name')
+        label = obj.findtext("name")
         if name_converter:
             if label in name_converter:
                 label = name_converter[label]
@@ -173,51 +176,53 @@ def get_coco_annotation_from_obj(obj, label2id, name_converter = None):
             return []
     category_id = label2id[label]
 
-    bndbox = obj.find('bndbox')
+    bndbox = obj.find("bndbox")
     if bndbox is None:
-        bndbox = obj.find('bbox')
+        bndbox = obj.find("bbox")
         if bndbox is None:
             return None
 
-    xmin = int(float(bndbox.findtext('xmin'))) - 1
-    ymin = int(float(bndbox.findtext('ymin'))) - 1
-    xmax = int(float(bndbox.findtext('xmax')))
-    ymax = int(float(bndbox.findtext('ymax')))
-    assert xmax > xmin and ymax > ymin, \
-        f"Box size error !: (xmin, ymin, xmax, ymax): {xmin, ymin, xmax, ymax}"
+    xmin = int(float(bndbox.findtext("xmin"))) - 1
+    ymin = int(float(bndbox.findtext("ymin"))) - 1
+    xmax = int(float(bndbox.findtext("xmax")))
+    ymax = int(float(bndbox.findtext("ymax")))
+    assert xmax > xmin and ymax > ymin, f"Box size error !: (xmin, ymin, xmax, ymax): {xmin, ymin, xmax, ymax}"
     o_width = xmax - xmin
     o_height = ymax - ymin
     return {
-        'area': o_width * o_height,
-        'iscrowd': 0,
-        'bbox': [xmin, ymin, o_width, o_height],
-        'category_id': category_id,
-        'ignore': 0,
-        'segmentation': []  # This script is not for segmentation
+        "area": o_width * o_height,
+        "iscrowd": 0,
+        "bbox": [xmin, ymin, o_width, o_height],
+        "category_id": category_id,
+        "ignore": 0,
+        "segmentation": [],  # This script is not for segmentation
     }
 
-def convert_bbox_to_coco(annotation: List[str],
-                         label2id: Dict[str, int],
-                         output_jsonpath: str,
-                         output_imgpath: str,
-                         general_info,
-                         image_id_list = None,
-                         bnd_id_list = None,
-                         get_label_from_folder = False,
-                         resize = 1.0,
-                         add_foldername = False,
-                         extract_num_from_imgid = False):
+
+def convert_bbox_to_coco(
+    annotation: List[str],
+    label2id: Dict[str, int],
+    output_jsonpath: str,
+    output_imgpath: str,
+    general_info,
+    image_id_list=None,
+    bnd_id_list=None,
+    get_label_from_folder=False,
+    resize=1.0,
+    add_foldername=False,
+    extract_num_from_imgid=False,
+):
     """
     Annotation Format
     -----------------
     "image name" "the number of bounding boxes(bb)" "x1" "y1" "x2" "y2" "label" "score" "x1" "y1" "x2" "y2" ...
-    
+
     For example, the following line:
-    
+
     TRAIN_RGB/n12710693_12225.png 5 515 68 759 285 2 1.000 624 347 868 582 2 1.000 480 488 693 712 2 1.000 44 433 268 657 2 1.000 112 198 342 401 2 1.000
-    
-    will become: 
-    
+
+    will become:
+
     image name=TRAIN_RGB/n12710693_12225.png
     the number of bb=5
     x1=515
@@ -226,32 +231,29 @@ def convert_bbox_to_coco(annotation: List[str],
     y2=285
     label=2 "0=background, 1=capsicum, 2=rockmelon..."
     score=1.000
-    
+
     Reference: https://drive.google.com/drive/folders/1CmsZb1caggLRN7ANfika8WuPiywo4mBb
     """
-    output_json_dict = {
-        "images": [], "type": "instances", "annotations": [],
-        "categories": [], 'info': general_info}
+    output_json_dict = {"images": [], "type": "instances", "annotations": [], "categories": [], "info": general_info}
 
     # TODO: Use multi thread to boost up the speed
     print("Converting annotations into COCO JSON and process the images")
     for img_idx, anno_line in enumerate(tqdm(annotation)):
-
         if image_id_list:
             img_unique_id = image_id_list[img_idx]
         else:
             if extract_num_from_imgid:
-                filename = anno_line[0].split('/')[-1]
-                img_unique_id = int(''.join(filter(str.isdigit, filename)))
+                filename = anno_line[0].split("/")[-1]
+                img_unique_id = int("".join(filter(str.isdigit, filename)))
             else:
                 img_unique_id = img_idx + 1
 
         img_info, img = get_image_info_from_annoline(
-            annotation_root = anno_line, idx = img_unique_id,
-            resize = resize, add_foldername = add_foldername)
+            annotation_root=anno_line, idx=img_unique_id, resize=resize, add_foldername=add_foldername
+        )
 
         if img_info:
-            output_json_dict['images'].append(img_info)
+            output_json_dict["images"].append(img_info)
 
             bbox_cnt = int(anno_line[1])
             if bbox_cnt > 0:
@@ -260,12 +262,12 @@ def convert_bbox_to_coco(annotation: List[str],
                     if get_label_from_folder:
                         # Change label based on folder
                         try:
-                            category_name = anno_line[0].split('/')[-3]
+                            category_name = anno_line[0].split("/")[-3]
                             if category_name not in label2id:
                                 raise
                         except:
                             try:
-                                category_name = anno_line[0].split('/')[-2]
+                                category_name = anno_line[0].split("/")[-2]
                                 if category_name not in label2id:
                                     raise
                             except Exception as e:
@@ -279,8 +281,7 @@ def convert_bbox_to_coco(annotation: List[str],
                         pass
 
                     try:
-                        ann = get_coco_annotation_from_annoline(
-                            obj = obj, resize = resize)
+                        ann = get_coco_annotation_from_annoline(obj=obj, resize=resize)
                     except:
                         ann = None
 
@@ -288,94 +289,89 @@ def convert_bbox_to_coco(annotation: List[str],
                         if bnd_id_list:
                             bnd_idx = bnd_id_list[img_idx][bnd_idx]
                         else:
-                            bnd_idx + 1 # noqa
-                        ann.update({'image_id': img_info['id'], 'id': bnd_idx})
-                        output_json_dict['annotations'].append(ann)
+                            bnd_idx + 1  # noqa
+                        ann.update({"image_id": img_info["id"], "id": bnd_idx})
+                        output_json_dict["annotations"].append(ann)
 
-            img_name = img_info['file_name']
+            img_name = img_info["file_name"]
             dest_path = os.path.join(output_imgpath, img_name)
             try:
                 if resize == 1.0:
                     shutil.copyfile(anno_line[0], dest_path)
                 else:
                     cv2.imwrite(dest_path, img)
-            except: # Cannot copy the image file
+            except:  # Cannot copy the image file
                 pass
 
-        else: # Not valid image => Delete from annotation
+        else:  # Not valid image => Delete from annotation
             pass
 
     for label, label_id in label2id.items():
-        category_info = {'supercategory': 'none', 'id': label_id, 'name': label}
-        output_json_dict['categories'].append(category_info)
+        category_info = {"supercategory": "none", "id": label_id, "name": label}
+        output_json_dict["categories"].append(category_info)
 
-    with open(output_jsonpath, 'w') as f:
+    with open(output_jsonpath, "w") as f:
         output_json = json.dumps(output_json_dict)
         f.write(output_json)
 
     return output_json_dict
 
-def convert_xmls_to_cocojson(general_info,
-                             annotation_paths: List[str],
-                             img_paths: List[str],
-                             label2id: Dict[str, int],
-                             name_converter,
-                             output_jsonpath: str,
-                             output_imgpath: str,
-                             extract_num_from_imgid: bool = True):
+
+def convert_xmls_to_cocojson(
+    general_info,
+    annotation_paths: List[str],
+    img_paths: List[str],
+    label2id: Dict[str, int],
+    name_converter,
+    output_jsonpath: str,
+    output_imgpath: str,
+    extract_num_from_imgid: bool = True,
+):
     """Converts the XML annotation format into COCO JSON."""
-    output_json_dict = {
-        "images": [],
-        "type": "instances",
-        "annotations": [],
-        "categories": [],
-        "info": general_info
-    }
+    output_json_dict = {"images": [], "type": "instances", "annotations": [], "categories": [], "info": general_info}
     bnd_id = 1  # START_BOUNDING_BOX_ID, TODO input as args ?
-    print('Start converting !')
+    print("Start converting !")
     for img_idx, a_path in enumerate(tqdm(annotation_paths)):
         # Read annotation xml
         ann_tree = ET.parse(a_path)
         ann_root = ann_tree.getroot()
 
         if extract_num_from_imgid:
-            filename = a_path.split('/')[-1]
-            img_unique_id = int(''.join(filter(str.isdigit, filename)))
+            filename = a_path.split("/")[-1]
+            img_unique_id = int("".join(filter(str.isdigit, filename)))
         else:
             img_unique_id = img_idx + 1
 
         if len(img_paths) == len(annotation_paths):
             ann_root.find("filename").text = img_paths[img_idx]
 
-        img_info, img = get_image_info(
-            annotation_root = ann_root, idx = img_unique_id,
-            resize = 1.0, add_foldername = False)
-        output_json_dict['images'].append(img_info)
+        img_info, img = get_image_info(annotation_root=ann_root, idx=img_unique_id, resize=1.0, add_foldername=False)
+        output_json_dict["images"].append(img_info)
 
-        for obj in ann_root.findall('object'):
-            ann = get_coco_annotation_from_obj(
-                obj = obj, label2id = label2id, name_converter = name_converter)
+        for obj in ann_root.findall("object"):
+            ann = get_coco_annotation_from_obj(obj=obj, label2id=label2id, name_converter=name_converter)
             if ann:
-                ann.update({'image_id': img_info['id'], 'id': bnd_id})
-                output_json_dict['annotations'].append(ann)
+                ann.update({"image_id": img_info["id"], "id": bnd_id})
+                output_json_dict["annotations"].append(ann)
                 bnd_id = bnd_id + 1
 
         # Process images
-        img_name = img_info['file_name']
+        img_name = img_info["file_name"]
         dest_path = os.path.join(output_imgpath, img_name)
         try:
             cv2.imwrite(dest_path, img)
-        except: # Cannot copy the image file
+        except:  # Cannot copy the image file
             pass
 
     for label, label_id in label2id.items():
-        category_info = {'supercategory': 'none', 'id': label_id, 'name': label}
-        output_json_dict['categories'].append(category_info)
+        category_info = {"supercategory": "none", "id": label_id, "name": label}
+        output_json_dict["categories"].append(category_info)
 
-    with open(output_jsonpath, 'w') as f:
+    with open(output_jsonpath, "w") as f:
         output_json = json.dumps(output_json_dict)
         f.write(output_json)
 
+
 # Reference: https://www.immersivelimit.com/create-coco-annotations-from-scratch
 def create_sub_masks(mask_image):
     width, height = mask_image.size
@@ -397,19 +393,20 @@ def create_sub_masks(mask_image):
                     # Note: we add 1 pixel of padding in each direction
                     # because the contours module doesn't handle cases
                     # where pixels bleed to the edge of the image
-                    sub_masks[pixel_str] = Image.new('1', (width + 2, height + 2))
+                    sub_masks[pixel_str] = Image.new("1", (width + 2, height + 2))
 
                 # Set the pixel value to 1 (default is 0), accounting for padding
                 sub_masks[pixel_str].putpixel((x + 1, y + 1), 1)
 
     return sub_masks
 
+
 # Reference: https://www.immersivelimit.com/create-coco-annotations-from-scratch
 def create_sub_mask_annotation(sub_mask, image_id, category_id, annotation_id, is_crowd):
     # Find contours (boundary lines) around each sub-mask
     # Note: there could be multiple contours if the object
     # is partially occluded. (E.g. an elephant behind a tree)
-    contours = measure.find_contours(sub_mask, 0.5, positive_orientation = 'low')
+    contours = measure.find_contours(sub_mask, 0.5, positive_orientation="low")
 
     segmentations = []
     polygons = []
@@ -422,7 +419,7 @@ def create_sub_mask_annotation(sub_mask, image_id, category_id, annotation_id, i
 
         # Make a polygon and simplify it
         poly = Polygon(contour)
-        poly = poly.simplify(1.0, preserve_topology = False)
+        poly = poly.simplify(1.0, preserve_topology=False)
         polygons.append(poly)
         segmentation = np.array(poly.exterior.coords).ravel().tolist()
         segmentations.append(segmentation)
@@ -436,23 +433,24 @@ def create_sub_mask_annotation(sub_mask, image_id, category_id, annotation_id, i
     area = multi_poly.area
 
     annotation = {
-        'segmentation': segmentations,
-        'iscrowd': is_crowd,
-        'image_id': image_id,
-        'category_id': category_id,
-        'id': annotation_id,
-        'bbox': bbox,
-        'area': area
+        "segmentation": segmentations,
+        "iscrowd": is_crowd,
+        "image_id": image_id,
+        "category_id": category_id,
+        "id": annotation_id,
+        "bbox": bbox,
+        "area": area,
     }
 
     return annotation
 
+
 def create_sub_mask_annotation_per_bbox(sub_mask, image_id, category_id, annotation_id, is_crowd):
     # Find contours (boundary lines) around each sub-mask
     # Note: there could be multiple contours if the object
     # is partially occluded. (E.g. an elephant behind a tree)
     sub_mask_np = np.array(sub_mask)
-    contours = measure.find_contours(sub_mask_np, 0.5, positive_orientation = 'low')
+    contours = measure.find_contours(sub_mask_np, 0.5, positive_orientation="low")
 
     segmentations = []
     polygons = []
@@ -466,7 +464,7 @@ def create_sub_mask_annotation_per_bbox(sub_mask, image_id, category_id, annotat
 
         # Make a polygon and simplify it
         poly = Polygon(contour)
-        poly = poly.simplify(1.0, preserve_topology = False)
+        poly = poly.simplify(1.0, preserve_topology=False)
         polygons.append(poly)
         segmentation = np.array(poly.exterior.coords).ravel().tolist()
         segmentations.append(segmentation)
@@ -480,15 +478,17 @@ def create_sub_mask_annotation_per_bbox(sub_mask, image_id, category_id, annotat
             bbox = (x, y, width, height)
             area = multi_poly.area
 
-            annotations.append({
-                'segmentation': [segmentation],
-                'iscrowd': is_crowd,
-                'image_id': image_id,
-                'category_id': category_id,
-                'id': annotation_id + idx,
-                'bbox': bbox,
-                'area': area
-            })
+            annotations.append(
+                {
+                    "segmentation": [segmentation],
+                    "iscrowd": is_crowd,
+                    "image_id": image_id,
+                    "category_id": category_id,
+                    "id": annotation_id + idx,
+                    "bbox": bbox,
+                    "area": area,
+                }
+            )
 
     return annotations
 
@@ -502,17 +502,17 @@ def mask_annotation_per_bbox(anno_line, image_id, category_id, annotation_id, is
     annotations = []
     mask_data = json.loads(anno_line[5])
 
-    if len(mask_data['all_points_x']) > 3:
+    if len(mask_data["all_points_x"]) > 3:
         # Flip from (row, col) representation to (x, y)
         # and subtract the padding pixel
         contour = []
-        for i in range(len(mask_data['all_points_x'])):
-            contour.append([int(mask_data['all_points_x'][i]), int(mask_data['all_points_y'][i])])
+        for i in range(len(mask_data["all_points_x"])):
+            contour.append([int(mask_data["all_points_x"][i]), int(mask_data["all_points_y"][i])])
 
         contour = np.array(contour)
         # Make a polygon and simplify it
         poly = Polygon(contour)
-        poly = poly.simplify(1.0, preserve_topology = False)
+        poly = poly.simplify(1.0, preserve_topology=False)
         polygons.append(poly)
         # Only need the contours, not the polygon itself:
         # segmentation = np.array(poly.exterior.coords).ravel().tolist()
@@ -529,37 +529,43 @@ def mask_annotation_per_bbox(anno_line, image_id, category_id, annotation_id, is
             area = poly.area
 
             annotation = {
-                'segmentation': [segmentation],
-                'iscrowd': is_crowd,
-                'image_id': image_id,
-                'category_id': category_id,
-                'id': annotation_id,
-                'bbox': bbox,
-                'area': area
+                "segmentation": [segmentation],
+                "iscrowd": is_crowd,
+                "image_id": image_id,
+                "category_id": category_id,
+                "id": annotation_id,
+                "bbox": bbox,
+                "area": area,
             }
             annotations.append(annotation)
 
     return annotations
 
+
 def move_segmentation_dataset(
-        out_dir, dataset_name, train_images, annotation_images, train_dir,
-        annotation_dir, train_preprocess_fn = None, annotation_preprocess_fn = None):
+    out_dir,
+    dataset_name,
+    train_images,
+    annotation_images,
+    train_dir,
+    annotation_dir,
+    train_preprocess_fn=None,
+    annotation_preprocess_fn=None,
+):
     """Moves segmentation images and annotations to a new location."""
     processed_dir = os.path.join(out_dir, dataset_name)
-    os.makedirs(processed_dir, exist_ok = True)
-    processed_image_dir = os.path.join(processed_dir, 'images')
-    os.makedirs(processed_image_dir, exist_ok = True)
-    processed_annotation_dir = os.path.join(processed_dir, 'annotations')
-    os.makedirs(processed_annotation_dir, exist_ok = True)
+    os.makedirs(processed_dir, exist_ok=True)
+    processed_image_dir = os.path.join(processed_dir, "images")
+    os.makedirs(processed_image_dir, exist_ok=True)
+    processed_annotation_dir = os.path.join(processed_dir, "annotations")
+    os.makedirs(processed_annotation_dir, exist_ok=True)
     for image_path, annotation_path in zip(
-            tqdm(train_images, desc = "Processing Images",
-                 file = sys.stdout), annotation_images):
+        tqdm(train_images, desc="Processing Images", file=sys.stdout), annotation_images
+    ):
         orig_image_path = os.path.join(train_dir, image_path)
         orig_annotation_path = os.path.join(annotation_dir, annotation_path)
-        out_image_path = os.path.join(
-            processed_image_dir, image_path)
-        out_label_path = os.path.join(
-            processed_annotation_dir, annotation_path)
+        out_image_path = os.path.join(processed_image_dir, image_path)
+        out_label_path = os.path.join(processed_annotation_dir, annotation_path)
         if train_preprocess_fn is None:
             shutil.copyfile(orig_image_path, out_image_path)
         else:
diff --git a/agml/_internal/s3internal.py b/agml/_internal/s3internal.py
index 9fe4c525..1d985b81 100644
--- a/agml/_internal/s3internal.py
+++ b/agml/_internal/s3internal.py
@@ -16,11 +16,11 @@
 Internal class for interacting with the AgML public dataset S3 bucket.
 """
 
+import json
 import os
 import sys
-import json
-import zipfile
 import warnings
+import zipfile
 
 import boto3
 import botocore.exceptions
@@ -34,16 +34,19 @@ class InternalAgMLS3API(object):
 
     *Note*: This class should only be used by the AgML developers.
     """
+
     def __init__(self):
         # Read in metadata for data sources file
         self.data_srcs_path = os.path.join(
             os.path.dirname(os.path.dirname(__file__)),
-            '_assets', 'public_datasources.json')
+            "_assets",
+            "public_datasources.json",
+        )
         with open(self.data_srcs_path) as f:
             self.data_srcs = json.load(f)
 
         # Define s3 bucket URI
-        self.agdata_s3_uri = 'https://s3.us-west-1.amazonaws.com/agdata-data/'
+        self.agdata_s3_uri = "https://s3.us-west-1.amazonaws.com/agdata-data/"
 
         # Initialize attribute for storing dataset download path
         self.dataset_download_path = None
@@ -56,7 +59,7 @@ def data_sources(self):
     def upload_dataset(self, dataset_name, dataset_dir):
         """
         Uploads dataset to agdata-data s3 file storage.
-        
+
         Parameters
         ----------
         dataset_name : str
@@ -65,24 +68,30 @@ def upload_dataset(self, dataset_name, dataset_dir):
             path to directory where dataset is stored
         """
         # Establish connection with s3 via boto
-        self.s3 = boto3.client('s3')
+        self.s3 = boto3.client("s3")
 
         # Setup progress bar
         self.pg = tqdm(
-            total=os.stat(os.path.abspath(os.path.join(dataset_dir, dataset_name + '.zip'))).st_size,
-            file=sys.stdout, desc=f"Uploading {dataset_name}")
+            total=os.stat(os.path.abspath(os.path.join(dataset_dir, dataset_name + ".zip"))).st_size,
+            file=sys.stdout,
+            desc=f"Uploading {dataset_name}",
+        )
 
         # Upload data to agdata-data bucket
         try:
-            with open(os.path.join(dataset_dir, dataset_name + '.zip'), 'rb') as data:
-                self.s3.upload_fileobj(Fileobj=data, 
-                                       Bucket='agdata-data',
-                                       Key='datasets/' + dataset_name + '.zip',
-                                       Callback=lambda x: self.pg.update(x))
+            with open(os.path.join(dataset_dir, dataset_name + ".zip"), "rb") as data:
+                self.s3.upload_fileobj(
+                    Fileobj=data,
+                    Bucket="agdata-data",
+                    Key="datasets/" + dataset_name + ".zip",
+                    Callback=lambda x: self.pg.update(x),
+                )
         except:
             warnings.warn(
-                f'Upload of {dataset_name} unsuccessful. You may not have permission '
-                f'to upload to the agdata-data s3 bucket.', category = UserWarning)
+                f"Upload of {dataset_name} unsuccessful. You may not have permission "
+                f"to upload to the agdata-data s3 bucket.",
+                category=UserWarning,
+            )
         finally:
             self.pg.close()
 
@@ -97,31 +106,37 @@ def upload_model(self, model_name, model_dir):
             path to directory where model is stored
         """
         # Establish connection with s3 via boto
-        self.s3 = boto3.client('s3')
+        self.s3 = boto3.client("s3")
 
         # Setup progress bar
         self.pg = tqdm(
-            total=os.stat(os.path.abspath(os.path.join(model_dir, model_name + '.pth'))).st_size,
-            file=sys.stdout, desc = f"Uploading {model_name}")
+            total=os.stat(os.path.abspath(os.path.join(model_dir, model_name + ".pth"))).st_size,
+            file=sys.stdout,
+            desc=f"Uploading {model_name}",
+        )
 
         # Upload data to agdata-data bucket
         try:
-            with open(os.path.join(model_dir, model_name + '.pth'), 'rb') as data:
-                self.s3.upload_fileobj(Fileobj=data, 
-                                       Bucket='agdata-data',
-                                       Key='models/' + model_name + '.pth',
-                                       Callback=lambda x: self.pg.update(x))
+            with open(os.path.join(model_dir, model_name + ".pth"), "rb") as data:
+                self.s3.upload_fileobj(
+                    Fileobj=data,
+                    Bucket="agdata-data",
+                    Key="models/" + model_name + ".pth",
+                    Callback=lambda x: self.pg.update(x),
+                )
         except:
             warnings.warn(
-                f'Upload of {model_name} unsuccessful. You may not have permission '
-                f'to upload to the agdata-data s3 bucket.', category = UserWarning)
+                f"Upload of {model_name} unsuccessful. You may not have permission "
+                f"to upload to the agdata-data s3 bucket.",
+                category=UserWarning,
+            )
         finally:
             self.pg.close()
 
     def download_dataset(self, dataset_name, dest_dir):
         """
         Downloads dataset from agdata-data s3 file storage.
-        
+
         Parameters
         ----------
         dataset_name : str
@@ -134,39 +149,43 @@ def download_dataset(self, dataset_name, dest_dir):
             raise ValueError(f"Invalid dataset '{dataset_name}.'")
 
         # Establish connection with s3 via boto
-        self.s3 = boto3.client('s3')
-        self.s3_resource = boto3.resource('s3')
+        self.s3 = boto3.client("s3")
+        self.s3_resource = boto3.resource("s3")
 
         # Setup progress bar
         try:
             self.pg = tqdm(
-                total=float(self.s3_resource.ObjectSummary(
-                    bucket_name='agdata-data', key=dataset_name + '.zip').size),
-                file=sys.stdout, desc = f"Downloading {dataset_name}")
+                total=float(self.s3_resource.ObjectSummary(bucket_name="agdata-data", key=dataset_name + ".zip").size),
+                file=sys.stdout,
+                desc=f"Downloading {dataset_name}",
+            )
         except botocore.exceptions.ClientError as ce:
             if "Not Found" in str(ce):
                 raise ValueError(
                     f"The dataset '{dataset_name}' could not be found in "
-                    f"the bucket, perhaps it has not been uploaded yet.")
+                    f"the bucket, perhaps it has not been uploaded yet."
+                )
             raise ce
 
         # File path of zipped dataset
-        self.dataset_download_path = os.path.join(dest_dir, dataset_name + '.zip')
+        self.dataset_download_path = os.path.join(dest_dir, dataset_name + ".zip")
 
         # Upload data to agdata-data bucket
-        with open(self.dataset_download_path, 'wb') as data:
-            self.s3.download_fileobj(Bucket='agdata-data', 
-                                     Key=dataset_name + '.zip', 
-                                     Fileobj=data,
-                                     Callback=lambda x: self.pg.update(x))
+        with open(self.dataset_download_path, "wb") as data:
+            self.s3.download_fileobj(
+                Bucket="agdata-data",
+                Key=dataset_name + ".zip",
+                Fileobj=data,
+                Callback=lambda x: self.pg.update(x),
+            )
         self.pg.close()
 
         # Unzip downloaded dataset
-        with zipfile.ZipFile(self.dataset_download_path, 'r') as z:
+        with zipfile.ZipFile(self.dataset_download_path, "r") as z:
             z.printdir()
-            print('Extracting files...')
+            print("Extracting files...")
             z.extractall(path=dest_dir)
-            print('Done!')
+            print("Done!")
 
         # Delete zipped file
         os.remove(self.dataset_download_path)
diff --git a/agml/_internal/syntheticdata.py b/agml/_internal/syntheticdata.py
index de747643..f2e22fe9 100644
--- a/agml/_internal/syntheticdata.py
+++ b/agml/_internal/syntheticdata.py
@@ -1,6 +1,6 @@
 import json
-import csv 
-import copy 
+import csv
+import copy
 import os
 import numpy as np
 from dict2xml import dict2xml
@@ -16,23 +16,22 @@
 import matplotlib.pyplot as plt
 import xml.etree.ElementTree as ET
 
-HELIOS_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), '_helios/Helios')
+HELIOS_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "_helios/Helios")
 
 
 class HeliosDataGenerator(object):
-
     def __init__(self, path_helios_dir=HELIOS_PATH):
-        self.path_canopygen_header = os.path.join(
-            path_helios_dir, 'plugins/canopygenerator/include/CanopyGenerator.h')
-        self.path_canopygen_cpp = os.path.join(
-            path_helios_dir, 'plugins/canopygenerator/src/CanopyGenerator.cpp')
+        self.path_canopygen_header = os.path.join(path_helios_dir, "plugins/canopygenerator/include/CanopyGenerator.h")
+        self.path_canopygen_cpp = os.path.join(path_helios_dir, "plugins/canopygenerator/src/CanopyGenerator.cpp")
         self.path_cmakelists = os.path.join(
-            os.path.dirname(os.path.dirname(__file__)), '_helios/Helios/projects/SyntheticImageAnnotation/CMakeLists.txt')
+            os.path.dirname(os.path.dirname(__file__)),
+            "_helios/Helios/projects/SyntheticImageAnnotation/CMakeLists.txt",
+        )
         self.path_main_cpp = os.path.join(
-            os.path.dirname(os.path.dirname(__file__)), '_helios/Helios/projects/SyntheticImageAnnotation/main.cpp')
+            os.path.dirname(os.path.dirname(__file__)), "_helios/Helios/projects/SyntheticImageAnnotation/main.cpp"
+        )
 
-        self.path_lidar_cpp = os.path.join(
-            path_helios_dir, 'plugins/lidar/src/LiDAR.cpp')
+        self.path_lidar_cpp = os.path.join(path_helios_dir, "plugins/lidar/src/LiDAR.cpp")
         self.canopy_types = self.get_canopy_types()
         self.canopy_params = self.get_canopy_params()
         self.canopy_param_ranges = self.set_initial_canopy_param_ranges()
@@ -42,7 +41,6 @@ def __init__(self, path_helios_dir=HELIOS_PATH):
         self.camera_param_ranges = self.set_initial_camera_param_ranges()
 
     def get_canopy_types(self):
-
         """
         Find all occurrences of 'struct' in canopygen_header_txt.
         Parse canopy type from struct occurrences.
@@ -55,11 +53,11 @@ def get_canopy_types(self):
 
         # Generate list of canopy types
         canopy_types = []
-        search_term = 'struct '
+        search_term = "struct "
         length_search_term = len(search_term)
         for i, string in enumerate(canopygen_header_txt):
             if search_term in string:
-                canopy_types.append(string[length_search_term:].split('Parameters{')[0])
+                canopy_types.append(string[length_search_term:].split("Parameters{")[0])
 
         return canopy_types
 
@@ -67,7 +65,6 @@ def set_seed(self, seed):
         np.random.seed(seed)
 
     def get_canopy_params(self):
-
         # Flag for parsing
         param_flag = 0
 
@@ -80,41 +77,39 @@ def get_canopy_params(self):
 
             # Find parameters for each canopy type
         for canopy_type in self.canopy_types:
-
             # Find first line of parameter definition in cpp file
-            search_term = canopy_type + 'Parameters::'
+            search_term = canopy_type + "Parameters::"
 
             for i, string in enumerate(canopygen_header_txt):
-
                 if param_flag == 1:
-                    if string != '\n' and string != '}\n' and string != '  \n':
-                        line = string.split(';\n')[0]
-                        key, value = line.split(' = ')
+                    if string != "\n" and string != "}\n" and string != "  \n":
+                        line = string.split(";\n")[0]
+                        key, value = line.split(" = ")
 
-                        if '(' in value:
-                            value = value.split('(')[1].split(')')[0].replace(',', ' ')
+                        if "(" in value:
+                            value = value.split("(")[1].split(")")[0].replace(",", " ")
 
-                        canopy_params[canopy_type][key.strip()] = value.strip().strip('\"').replace('\n', '').replace(
-                            ';', '').replace('.f', '0')
+                        canopy_params[canopy_type][key.strip()] = (
+                            value.strip().strip('"').replace("\n", "").replace(";", "").replace(".f", "0")
+                        )
 
                         if len(canopy_params[canopy_type][key.strip()]) == 1:
                             canopy_params[canopy_type][key.strip()] = canopy_params[canopy_type][key.strip()][0]
 
-                        if 'M_PI' in value:
-                            new_val = float(value.split('*')[0]) * 3.14159
+                        if "M_PI" in value:
+                            new_val = float(value.split("*")[0]) * 3.14159
                             canopy_params[canopy_type][key.strip()] = str(new_val)
 
                 if search_term in string:
                     canopy_params[canopy_type] = {}
                     param_flag = 1
 
-                if '}' in string and param_flag == 1:
+                if "}" in string and param_flag == 1:
                     param_flag = 0
 
         return canopy_params
 
     def get_lidar_params(self):
-
         # Flag for parsing
         param_flag = 0
 
@@ -126,103 +121,100 @@ def get_lidar_params(self):
             LiDAR_txt = f.readlines()
 
             # Find Metadata line of parameter definition in cpp file
-            search_term = 'ScanMetadata::ScanMetadata'
+            search_term = "ScanMetadata::ScanMetadata"
 
             for i, string in enumerate(LiDAR_txt):
-
                 if param_flag == 1:
-
-                    if string != '\n' and string != '}\n' and string != '  \n' and string != '  //Copy arguments into structure variables\n':
-
-                        line = string.split(';\n')[0]
-                        key = line.split(' = ')
+                    if (
+                        string != "\n"
+                        and string != "}\n"
+                        and string != "  \n"
+                        and string != "  //Copy arguments into structure variables\n"
+                    ):
+                        line = string.split(";\n")[0]
+                        key = line.split(" = ")
                         # Initialization of values from Helios -- Need to read this values from c++
-                        if key[0].strip() == 'origin':
-                            lidar_params[key[0].strip()] = '0 0 0'
-                        elif key[0].strip() == 'Ntheta':
-                            lidar_params['size'] = '250'
-                        elif key[0].strip() == 'thetaMin':
-                            lidar_params[key[0].strip()] = '0'
-                        elif key[0].strip() == 'thetaMax':
-                            lidar_params[key[0].strip()] = '180'
-                        elif key[0].strip() == 'Nphi':
-                            lidar_params['size'] = lidar_params['size'] + ' 450'
-                        elif key[0].strip() == 'phiMin':
-                            lidar_params[key[0].strip()] = '0'
-                        elif key[0].strip() == 'phiMax':
-                            lidar_params[key[0].strip()] = '360'
-                        elif key[0].strip() == 'exitDiameter':
-                            lidar_params[key[0].strip()] = '0'
-                        elif key[0].strip() == 'beamDivergence':
-                            lidar_params[key[0].strip()] = '0'
-                        elif key[0].strip() == 'columnFormat':
-                            lidar_params['ASCII_format'] = 'x y z'
-
-                if 'ScanMetadata::ScanMetadata' in string:
+                        if key[0].strip() == "origin":
+                            lidar_params[key[0].strip()] = "0 0 0"
+                        elif key[0].strip() == "Ntheta":
+                            lidar_params["size"] = "250"
+                        elif key[0].strip() == "thetaMin":
+                            lidar_params[key[0].strip()] = "0"
+                        elif key[0].strip() == "thetaMax":
+                            lidar_params[key[0].strip()] = "180"
+                        elif key[0].strip() == "Nphi":
+                            lidar_params["size"] = lidar_params["size"] + " 450"
+                        elif key[0].strip() == "phiMin":
+                            lidar_params[key[0].strip()] = "0"
+                        elif key[0].strip() == "phiMax":
+                            lidar_params[key[0].strip()] = "360"
+                        elif key[0].strip() == "exitDiameter":
+                            lidar_params[key[0].strip()] = "0"
+                        elif key[0].strip() == "beamDivergence":
+                            lidar_params[key[0].strip()] = "0"
+                        elif key[0].strip() == "columnFormat":
+                            lidar_params["ASCII_format"] = "x y z"
+
+                if "ScanMetadata::ScanMetadata" in string:
                     param_flag = 1
 
-                if '}' in string and param_flag == 1:
+                if "}" in string and param_flag == 1:
                     param_flag = 0
         return lidar_params
 
     def get_camera_params(self):
-
         # Initialize canopy parameters dictionary
         camera_params = {}
-        
+
         # Initialization of image resolution and camera position
-        camera_params['image_resolution'] = '600 400'
-        camera_params['camera_lookat'] = '0 0 1'
-        camera_params['camera_position'] = '0 -2 1'
-        
+        camera_params["image_resolution"] = "600 400"
+        camera_params["camera_lookat"] = "0 0 1"
+        camera_params["camera_position"] = "0 -2 1"
 
         return camera_params
 
     def set_initial_lidar_param_ranges(self):
-
         lidar_param_ranges = copy.deepcopy(self.lidar_params)
 
         # Check if parameter is a path or number; this assumes that all strings will be paths
         for i in lidar_param_ranges.keys():
-            if i == 'ASCII_format':
+            if i == "ASCII_format":
                 val = lidar_param_ranges[i]
-                lidar_param_ranges[i] = [(val.split(' ')[j].replace('f', '0')) for j in range(len(val.split()))]
+                lidar_param_ranges[i] = [(val.split(" ")[j].replace("f", "0")) for j in range(len(val.split()))]
             else:
                 val = lidar_param_ranges[i]
-                lidar_param_ranges[i] = [float(val.split(' ')[j].replace('f', '0')) for j in range(len(val.split()))]
+                lidar_param_ranges[i] = [float(val.split(" ")[j].replace("f", "0")) for j in range(len(val.split()))]
 
         return lidar_param_ranges
 
     def set_initial_canopy_param_ranges(self):
-
         canopy_param_ranges = copy.deepcopy(self.canopy_params)
 
         # Check if parameter is a path or number; this assumes that all strings will be paths
         for i in canopy_param_ranges.keys():
             for key in list(canopy_param_ranges[i]):
                 val = canopy_param_ranges[i][key]
-                if val.isalpha() or '/' in val or ':' in val:
+                if val.isalpha() or "/" in val or ":" in val:
                     canopy_param_ranges[i].pop(key)
                 else:
                     canopy_param_ranges[i][key] = [
-                        [float(val.split(' ')[j].replace('f', '0')), float(val.split(' ')[j].replace('f', '0'))] for j
-                        in range(len(val.split()))]
+                        [float(val.split(" ")[j].replace("f", "0")), float(val.split(" ")[j].replace("f", "0"))]
+                        for j in range(len(val.split()))
+                    ]
 
         return canopy_param_ranges
 
     def set_initial_camera_param_ranges(self):
-
         camera_param_ranges = copy.deepcopy(self.camera_params)
 
         # Check if parameter is a path or number; this assumes that all strings will be paths
         for i in camera_param_ranges.keys():
             val = camera_param_ranges[i]
-            camera_param_ranges[i] = [float(val.split(' ')[j]) for j in range(len(val.split()))]
+            camera_param_ranges[i] = [float(val.split(" ")[j]) for j in range(len(val.split()))]
 
         return camera_param_ranges
 
-    def generate_one_datapair(self, canopy_type, simulation_type, export_format = 'xml'):
-
+    def generate_one_datapair(self, canopy_type, simulation_type, export_format="xml"):
         """
         Find all occurrences of 'struct' in canopygen_header_txt.
         Parse canopy type from struct occurrences.
@@ -237,43 +229,59 @@ def generate_one_datapair(self, canopy_type, simulation_type, export_format = 'x
         export_format (string): default is xml for Helios
         """
 
-        assert canopy_type in self.canopy_types, 'Canopy type not available.'
+        assert canopy_type in self.canopy_types, "Canopy type not available."
 
-        assert export_format in ['xml', 'csv', 'json'], 'Only xml, csv and json export formats are possible.'
+        assert export_format in ["xml", "csv", "json"], "Only xml, csv and json export formats are possible."
 
         canopy_params_filtered = {k: v for k, v in self.canopy_params.items() if k.startswith(canopy_type)}
 
-        canopy_params_filtered[canopy_type + 'Parameters'] = canopy_params_filtered.pop(canopy_type)
+        canopy_params_filtered[canopy_type + "Parameters"] = canopy_params_filtered.pop(canopy_type)
 
-        canopy_params_filtered['Ground'] = {'origin': '0 0 0',
-                                            'extent': '10 10',
-                                            'texture_subtiles': '10 10',
-                                            'texture_subpatches': '1 1',
-                                            'ground_texture_file': 'plugins/canopygenerator/textures/dirt.jpg',
-                                            'rotation': '0'}
+        canopy_params_filtered["Ground"] = {
+            "origin": "0 0 0",
+            "extent": "10 10",
+            "texture_subtiles": "10 10",
+            "texture_subpatches": "1 1",
+            "ground_texture_file": "plugins/canopygenerator/textures/dirt.jpg",
+            "rotation": "0",
+        }
 
-        canopy_params_filtered = {'canopygenerator': canopy_params_filtered}
+        canopy_params_filtered = {"canopygenerator": canopy_params_filtered}
 
-        if simulation_type == 'lidar':
-            canopy_params_filtered['scan'] = self.lidar_params
+        if simulation_type == "lidar":
+            canopy_params_filtered["scan"] = self.lidar_params
 
-        if simulation_type == 'rgb':
-            canopy_params_filtered[''] = self.camera_params
+        if simulation_type == "rgb":
+            canopy_params_filtered[""] = self.camera_params
 
-        canopy_params_filtered = {'helios': canopy_params_filtered}
+        canopy_params_filtered = {"helios": canopy_params_filtered}
         from pprint import pprint
         # print(canopy_params_filtered)
 
-        if not os.path.exists(os.path.join(os.path.dirname(os.path.dirname(__file__)), '_helios/Helios/projects/SyntheticImageAnnotation/xml')):
-            os.makedirs(os.path.join(os.path.dirname(os.path.dirname(__file__)), '_helios/Helios/projects/SyntheticImageAnnotation/xml'))
-
-        if export_format == 'xml':
-            with open(os.path.join(os.path.dirname(os.path.dirname(__file__)), '_helios/Helios/projects/SyntheticImageAnnotation/xml/tmp_canopy_params_image.xml'), "w") as f:
+        if not os.path.exists(
+            os.path.join(
+                os.path.dirname(os.path.dirname(__file__)), "_helios/Helios/projects/SyntheticImageAnnotation/xml"
+            )
+        ):
+            os.makedirs(
+                os.path.join(
+                    os.path.dirname(os.path.dirname(__file__)), "_helios/Helios/projects/SyntheticImageAnnotation/xml"
+                )
+            )
+
+        if export_format == "xml":
+            with open(
+                os.path.join(
+                    os.path.dirname(os.path.dirname(__file__)),
+                    "_helios/Helios/projects/SyntheticImageAnnotation/xml/tmp_canopy_params_image.xml",
+                ),
+                "w",
+            ) as f:
                 f.write(dict2xml(canopy_params_filtered))
 
-    def generate_data(self, n_imgs, canopy_type, simulation_type, annotation_type, label_elements='none', output_directory = ".."):
-
-
+    def generate_data(
+        self, n_imgs, canopy_type, simulation_type, annotation_type, label_elements="none", output_directory=".."
+    ):
         """
         Given the path to the output of Helios, this method can be used to convert the data to a more standard format such as COCO JSON
 
@@ -285,52 +293,49 @@ def generate_data(self, n_imgs, canopy_type, simulation_type, annotation_type, l
         output_directory (string) (optional): optionally you may pass in a custom path to save the Helios output to the custom path
 
         """
-        output_directory=os.path.abspath(output_directory)
+        output_directory = os.path.abspath(output_directory)
 
-        assert simulation_type in ['rgb', 'lidar'], 'Simulation type unavailable.'
+        assert simulation_type in ["rgb", "lidar"], "Simulation type unavailable."
 
-        assert annotation_type in ['semantic', 'object', 'instance', 'none'], 'Annotation type unavailable.'
+        assert annotation_type in ["semantic", "object", "instance", "none"], "Annotation type unavailable."
 
-        Labels = label_elements.replace(' ', '').split(',')
+        Labels = label_elements.replace(" ", "").split(",")
 
         for j in range(len(Labels)):
-            assert Labels[j] in ['trunk', 'leaves', 'fruits', 'branches', 'ground', 'none'], 'Label type unavailable'
-
+            assert Labels[j] in ["trunk", "leaves", "fruits", "branches", "ground", "none"], "Label type unavailable"
 
         param_ranges = self.canopy_param_ranges[canopy_type]
 
         camera_ranges = self.camera_param_ranges
 
-        if simulation_type == 'lidar':
-            
+        if simulation_type == "lidar":
             lidar_ranges = copy.deepcopy(self.lidar_param_ranges)
-            
+
             # LiDAR parameters
             for key in lidar_ranges:
                 # param_vals=lidar_params[key].split(' ')
                 arr = [lidar_ranges[key][i] for i in range(len(lidar_ranges[key]))]
                 string_arr = [str(a) for a in arr]
-                self.lidar_params[key] = ' '.join(string_arr)
+                self.lidar_params[key] = " ".join(string_arr)
             # Mutiple LiDAR
             LiDARs = []
-            for i in range(len(lidar_ranges['origin'])):
+            for i in range(len(lidar_ranges["origin"])):
                 for key in lidar_ranges:
-                    if key == 'origin':
+                    if key == "origin":
                         arr = [lidar_ranges[key][i] for i in range(len(lidar_ranges[key]))]
                         arr = arr[i]
                         string_arr = [str(a) for a in arr]
-                        self.lidar_params[key] = ' '.join(string_arr)
+                        self.lidar_params[key] = " ".join(string_arr)
                     A = copy.deepcopy(self.lidar_params)
                 LiDARs.append(A)
             self.lidar_params = LiDARs
 
-        if simulation_type == 'rgb':
+        if simulation_type == "rgb":
             # Camera parameters
             for key in camera_ranges:
                 arr = [camera_ranges[key][i] for i in range(len(camera_ranges[key]))]
-                string_arr = [str(a).replace(',', '').replace('[', ' ').replace(']', ' ') for a in arr]
-                self.camera_params[key] = ' '.join(string_arr)
-
+                string_arr = [str(a).replace(",", "").replace("[", " ").replace("]", " ") for a in arr]
+                self.camera_params[key] = " ".join(string_arr)
 
         for n in range(n_imgs):
             params = self.canopy_params[canopy_type]
@@ -339,48 +344,58 @@ def generate_data(self, n_imgs, canopy_type, simulation_type, annotation_type, l
             # Context parameters
             for key in param_ranges:
                 print(param_ranges[key])
-                arr = [np.random.uniform(param_ranges[key][i][0], param_ranges[key][i][1]) for i in
-                       range(len(param_ranges[key]))]
+                arr = [
+                    np.random.uniform(param_ranges[key][i][0], param_ranges[key][i][1])
+                    for i in range(len(param_ranges[key]))
+                ]
                 string_arr = [str(a) for a in arr]
-                params[key] = ' '.join(string_arr)
+                params[key] = " ".join(string_arr)
             self.canopy_params[canopy_type] = params
             print(self.canopy_params[canopy_type])
 
             self.generate_one_datapair(canopy_type, simulation_type)
 
             # Re-write tags of XML to have the expected Helios input
-            tree = ET.parse(os.path.join(os.path.dirname(os.path.dirname(__file__)),
-                                         '_helios/Helios/projects/SyntheticImageAnnotation/xml',
-                                         'tmp_canopy_params_image.xml'))
+            tree = ET.parse(
+                os.path.join(
+                    os.path.dirname(os.path.dirname(__file__)),
+                    "_helios/Helios/projects/SyntheticImageAnnotation/xml",
+                    "tmp_canopy_params_image.xml",
+                )
+            )
             root = tree.getroot()
             for child in root:
-                if child.tag == 'camera_position':
-                    child.tag = 'globaldata_vec3'
-                    child.set('label', 'camera_position')
-                if child.tag == 'camera_lookat':
-                    child.tag = 'globaldata_vec3'
-                    child.set('label', 'camera_lookat')
-                if child.tag == 'image_resolution':
-                    child.tag = 'globaldata_int2'
-                    child.set('label', 'image_resolution')
-
-
-            tree.write(os.path.join(os.path.dirname(os.path.dirname(__file__)),
-                                    '_helios/Helios/projects/SyntheticImageAnnotation/xml', 'tmp_canopy_params_image.xml'))
+                if child.tag == "camera_position":
+                    child.tag = "globaldata_vec3"
+                    child.set("label", "camera_position")
+                if child.tag == "camera_lookat":
+                    child.tag = "globaldata_vec3"
+                    child.set("label", "camera_lookat")
+                if child.tag == "image_resolution":
+                    child.tag = "globaldata_int2"
+                    child.set("label", "image_resolution")
+
+            tree.write(
+                os.path.join(
+                    os.path.dirname(os.path.dirname(__file__)),
+                    "_helios/Helios/projects/SyntheticImageAnnotation/xml",
+                    "tmp_canopy_params_image.xml",
+                )
+            )
 
             # Modify cmake file for rgb versus lidar simulation
             with open(self.path_cmakelists) as f:
                 cmakelists_txt = f.readlines()
 
             for i, string in enumerate(cmakelists_txt):
-                if 'set( PLUGINS ' in string and simulation_type == 'lidar':
+                if "set( PLUGINS " in string and simulation_type == "lidar":
                     cmakelists_txt[i] = 'set( PLUGINS "lidar;visualizer;canopygenerator;syntheticannotation" )\n'
 
-                if 'set( PLUGINS ' in string and simulation_type == 'rgb':
+                if "set( PLUGINS " in string and simulation_type == "rgb":
                     cmakelists_txt[i] = 'set( PLUGINS "visualizer;canopygenerator;syntheticannotation" )\n'
 
             # and write everything back
-            with open(self.path_cmakelists, 'w') as f:
+            with open(self.path_cmakelists, "w") as f:
                 f.writelines(cmakelists_txt)
 
             # Modify maincpp file for rgb versus lidar simulation
@@ -389,14 +404,14 @@ def generate_data(self, n_imgs, canopy_type, simulation_type, annotation_type, l
 
             # Define paths for CMAKE compilation and output files
             current_directory = os.getcwd()
-            build_dir = os.path.join(current_directory, 'Helios/projects/SyntheticImageAnnotation/build')
+            build_dir = os.path.join(current_directory, "Helios/projects/SyntheticImageAnnotation/build")
             if output_directory == "":
-                output_dir = os.path.join(current_directory, 'Helios/projects/SyntheticImageAnnotation/output')
+                output_dir = os.path.join(current_directory, "Helios/projects/SyntheticImageAnnotation/output")
             else:
-                assert os.path.isdir(output_directory), 'Please, introduce a valid directory'
-                output_dir = output_directory + '/output'
-            point_cloud_dir = os.path.join(current_directory, output_dir + '/point_cloud/')
-            images_dir = os.path.join(current_directory, output_dir + '/images/')
+                assert os.path.isdir(output_directory), "Please, introduce a valid directory"
+                output_dir = output_directory + "/output"
+            point_cloud_dir = os.path.join(current_directory, output_dir + "/point_cloud/")
+            images_dir = os.path.join(current_directory, output_dir + "/images/")
 
             if not os.path.exists(build_dir):
                 os.makedirs(build_dir)
@@ -404,15 +419,15 @@ def generate_data(self, n_imgs, canopy_type, simulation_type, annotation_type, l
             if not os.path.exists(output_dir):
                 os.makedirs(output_dir)
 
-            if simulation_type == 'lidar':
+            if simulation_type == "lidar":
                 if not os.path.exists(point_cloud_dir):
                     os.makedirs(point_cloud_dir)
 
-            if simulation_type == 'rgb':
+            if simulation_type == "rgb":
                 if not os.path.exists(images_dir):
                     os.makedirs(images_dir)
 
-            exe = os.path.join(build_dir, 'SyntheticImageAnnotation')
+            exe = os.path.join(build_dir, "SyntheticImageAnnotation")
 
             # Modify main.cpp file for compilation in LIDAR and RGB case
             """
@@ -516,68 +531,82 @@ def generate_data(self, n_imgs, canopy_type, simulation_type, annotation_type, l
 
             default_xml_path = os.path.join(
                 os.path.dirname(os.path.dirname(__file__)),
-                '_helios/Helios/projects/SyntheticImageAnnotation/xml',
-                'tmp_canopy_params_image.xml')
+                "_helios/Helios/projects/SyntheticImageAnnotation/xml",
+                "tmp_canopy_params_image.xml",
+            )
             str_to_write = f"{annotation_type}\n{simulation_type}\n{' '.join(Labels)}\n{default_xml_path}\n{images_dir}"
-            with open(os.path.join(os.path.dirname(os.path.dirname(__file__)),
-                                   '_helios/Helios/projects/SyntheticImageAnnotation/config.txt'), 'w') as f:
+            with open(
+                os.path.join(
+                    os.path.dirname(os.path.dirname(__file__)),
+                    "_helios/Helios/projects/SyntheticImageAnnotation/config.txt",
+                ),
+                "w",
+            ) as f:
                 f.write(str_to_write)
 
-
             # System call to helios @DARIO
             # current_directory = os.getcwd()
-            helios_directory = os.path.join(os.path.dirname(os.path.dirname(__file__)), '_helios')
-            build_dir = os.path.join(helios_directory, 'Helios/projects/SyntheticImageAnnotation/build')
-            output_dir = os.path.join(helios_directory, 'Helios/projects/SyntheticImageAnnotation/output')
-            point_cloud_dir = os.path.join(helios_directory, 'Helios/projects/SyntheticImageAnnotation/output/point_cloud/')
-            images_dir = os.path.join(helios_directory, 'Helios/projects/SyntheticImageAnnotation/output/images/')
+            helios_directory = os.path.join(os.path.dirname(os.path.dirname(__file__)), "_helios")
+            build_dir = os.path.join(helios_directory, "Helios/projects/SyntheticImageAnnotation/build")
+            output_dir = os.path.join(helios_directory, "Helios/projects/SyntheticImageAnnotation/output")
+            point_cloud_dir = os.path.join(
+                helios_directory, "Helios/projects/SyntheticImageAnnotation/output/point_cloud/"
+            )
+            images_dir = os.path.join(helios_directory, "Helios/projects/SyntheticImageAnnotation/output/images/")
 
             if not os.path.exists(build_dir):
                 os.makedirs(build_dir)
-            
+
             if not os.path.exists(output_dir):
                 os.makedirs(output_dir)
 
-            if simulation_type == 'lidar':
+            if simulation_type == "lidar":
                 if not os.path.exists(point_cloud_dir):
                     os.makedirs(point_cloud_dir)
 
-            if simulation_type == 'rgb':
+            if simulation_type == "rgb":
                 if not os.path.exists(images_dir):
                     os.makedirs(images_dir)
 
-            exe = os.path.join(build_dir, 'SyntheticImageAnnotation')
+            exe = os.path.join(build_dir, "SyntheticImageAnnotation")
 
-            cmake_args = ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + build_dir]
-            cmake_args += ['-G', 'Unix Makefiles']
+            cmake_args = ["-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=" + build_dir]
+            cmake_args += ["-G", "Unix Makefiles"]
             # current_directory = os.getcwd()
-            helios_directory = os.path.join(os.path.dirname(os.path.dirname(__file__)), '_helios')
-            build_dir = os.path.join(helios_directory, 'Helios/projects/SyntheticImageAnnotation/build')
-            output_dir = os.path.join(helios_directory, 'Helios/projects/SyntheticImageAnnotation/output')
-            point_cloud_dir = os.path.join(helios_directory, 'Helios/projects/SyntheticImageAnnotation/output/point_cloud/')
-            images_dir = os.path.join(helios_directory, 'Helios/projects/SyntheticImageAnnotation/output/images/')
+            helios_directory = os.path.join(os.path.dirname(os.path.dirname(__file__)), "_helios")
+            build_dir = os.path.join(helios_directory, "Helios/projects/SyntheticImageAnnotation/build")
+            output_dir = os.path.join(helios_directory, "Helios/projects/SyntheticImageAnnotation/output")
+            point_cloud_dir = os.path.join(
+                helios_directory, "Helios/projects/SyntheticImageAnnotation/output/point_cloud/"
+            )
+            images_dir = os.path.join(helios_directory, "Helios/projects/SyntheticImageAnnotation/output/images/")
 
             if not os.path.exists(build_dir):
                 os.makedirs(build_dir)
-            
+
             if not os.path.exists(output_dir):
                 os.makedirs(output_dir)
 
-            if simulation_type == 'lidar':
+            if simulation_type == "lidar":
                 if not os.path.exists(point_cloud_dir):
                     os.makedirs(point_cloud_dir)
 
             if n == 0:
-                subprocess.run(['cmake', ".."] + cmake_args, cwd = build_dir, check = True)
-            subprocess.run(['cmake', '--build', '.'], cwd = build_dir, check = True)
-
-            subprocess.run([exe, '/Users/amoghjoshi/Documents/Amogh/Programs/Python/AgML/agml/_helios/Helios/projects/SyntheticImageAnnotation/config.txt',
-                            output_dir], cwd = build_dir)
+                subprocess.run(["cmake", ".."] + cmake_args, cwd=build_dir, check=True)
+            subprocess.run(["cmake", "--build", "."], cwd=build_dir, check=True)
+
+            subprocess.run(
+                [
+                    exe,
+                    "/Users/amoghjoshi/Documents/Amogh/Programs/Python/AgML/agml/_helios/Helios/projects/SyntheticImageAnnotation/config.txt",
+                    output_dir,
+                ],
+                cwd=build_dir,
+            )
 
         # self.convert_data() # Conversion to standard formats @PRANAV
 
-    def convert_data(self, Frames_path, annotation_format = 'instance_segmentation'):
-
+    def convert_data(self, Frames_path, annotation_format="instance_segmentation"):
         """
         Given the path to the output of Helios, this method can be used to convert the data to a more standard format such as COCO JSON
 
@@ -587,56 +616,55 @@ def convert_data(self, Frames_path, annotation_format = 'instance_segmentation')
 
         """
 
-        if annotation_format == 'object_detection':
+        if annotation_format == "object_detection":
             pass  # YOLO @PRANAV
-        if annotation_format == 'semantic_segmentation':
+        if annotation_format == "semantic_segmentation":
             pass  # single channel + mapping @PRANAV
-        if annotation_format == 'instance_segmentation' or annotation_format == 'object_detection':
-
+        if annotation_format == "instance_segmentation" or annotation_format == "object_detection":
             # data_path = sorted(os.listdir(data_path))
             frames_view = sorted(os.listdir(Frames_path))
             # Initialize a list of label numpy arrays
             # imgs = []
             # npy_arrs = []
             images = []
-            if not os.path.exists('./train_images/'):
-                os.mkdir('./train_images/')
+            if not os.path.exists("./train_images/"):
+                os.mkdir("./train_images/")
             for i, frame in enumerate(frames_view):
-                if frame == '.DS_Store':
+                if frame == ".DS_Store":
                     continue
 
-
                 else:
-
                     # Generate labels and append to list
-                    image, mask, pixel_ID = self.generate_npy_arr(Frames_path, Frames_path + frame + '/')
-                    plt.imsave('./train_images/' + frame + '.jpeg', image)
+                    image, mask, pixel_ID = self.generate_npy_arr(Frames_path, Frames_path + frame + "/")
+                    plt.imsave("./train_images/" + frame + ".jpeg", image)
 
                     strel = skimage.morphology.selem.disk(2)
 
                     # %% Convert masks to COCO for detectron implementation.
 
-                    mapping = pd.read_csv(Frames_path + frame + '/' + 'ID_mapping.txt', delim_whitespace = True,
-                                          names = ['ID', 'Class'])
+                    mapping = pd.read_csv(
+                        Frames_path + frame + "/" + "ID_mapping.txt", delim_whitespace=True, names=["ID", "Class"]
+                    )
 
-                    category = imantics.Category(mapping['Class'].iloc[pixel_ID],
-                                                 color = imantics.Color([255, 0, 0]))  # color for debug only
+                    category = imantics.Category(
+                        mapping["Class"].iloc[pixel_ID], color=imantics.Color([255, 0, 0])
+                    )  # color for debug only
                     c = 0
 
-                    im2 = imantics.Image(image_array = image, path = 'data/train_images/' + frame + '.jpeg',
-                                         id = i)  # imantics image object
+                    im2 = imantics.Image(
+                        image_array=image, path="data/train_images/" + frame + ".jpeg", id=i
+                    )  # imantics image object
 
                     for i in range(mask.shape[2]):  # create the polygons for each slice
-
-                        if annotation_format == 'instance_segmentation':
+                        if annotation_format == "instance_segmentation":
                             poly = imantics.Mask(closing(mask[:, :, i], strel)).polygons()
-                            ann = imantics.Annotation(image = im2, category = category, polygons = poly, id = c)
+                            ann = imantics.Annotation(image=im2, category=category, polygons=poly, id=c)
                             box = imantics.Mask(closing(mask[:, :, i], strel)).bbox()
                             # print(box)
 
-                        if annotation_format == 'object_detection':
+                        if annotation_format == "object_detection":
                             box = imantics.Mask(closing(mask[:, :, i], strel)).bbox()
-                            ann = imantics.Annotation(image = im2, category = category, bbox = box, id = c)
+                            ann = imantics.Annotation(image=im2, category=category, bbox=box, id=c)
                             # print(box)
                         c += 1
 
@@ -646,69 +674,68 @@ def convert_data(self, Frames_path, annotation_format = 'instance_segmentation')
 
                     images.append(im2)  # collect the image objects after they get polygons
                 # %% Create Imantics dataset and export
-            ds = imantics.Dataset(name = 'coco', images = images)
+            ds = imantics.Dataset(name="coco", images=images)
             obj = ds.coco()
-            with open('trainval.json', 'w') as json_file:
+            with open("trainval.json", "w") as json_file:
                 json.dump(obj, json_file)
             #     json_file.close()
             # obj=obj.clear()
             # del obj, ds, json_file, images
 
             # COCO json @PRANAV
-        if annotation_format == 'panoptic_segmentation':
+        if annotation_format == "panoptic_segmentation":
             pass
-        if annotation_format == 'regression':
+        if annotation_format == "regression":
             pass
 
     def generate_npy_arr(self, Frames_path, frames_view_path):
-
         Frame_paths = frames_view_path
 
         # Grab dimensions
-        render = imread(frames_view_path + '/RGB_rendering' + '.jpeg')
+        render = imread(frames_view_path + "/RGB_rendering" + ".jpeg")
         render_xy_shape = (render.shape[0], render.shape[1])
         # print(render_xy_shape)
 
         # Number of instances
         frames_list = []
-        exclude_files = ['RGB_rendering.jpeg', 'pixelID_combined.txt', 'ID_mapping.txt']
+        exclude_files = ["RGB_rendering.jpeg", "pixelID_combined.txt", "ID_mapping.txt"]
         frames_files = [x for x in os.listdir(frames_view_path) if x not in exclude_files]
         frames_list.append(frames_files)
         n_instances = [len(frame) for frame in frames_list]
 
         # Initialize numpy array of shape (x, y, n_instances)
-        npy_arr = np.zeros(shape = (render_xy_shape[0], render_xy_shape[1], n_instances[0]),
-                           dtype = np.bool_)  # Make boolean dtype
+        npy_arr = np.zeros(
+            shape=(render_xy_shape[0], render_xy_shape[1], n_instances[0]), dtype=np.bool_
+        )  # Make boolean dtype
 
         # Read frames as a list
         bboxes = []
         frames = []
         i = 0
         for file_grape_arr in os.listdir(frames_view_path):
-
-            if file_grape_arr == '.DS_Store':
+            if file_grape_arr == ".DS_Store":
                 continue
 
-            if file_grape_arr == 'pixelID_combined.txt':
+            if file_grape_arr == "pixelID_combined.txt":
                 continue
 
-            if file_grape_arr == 'ID_mapping.txt':
+            if file_grape_arr == "ID_mapping.txt":
                 continue
 
-            if file_grape_arr == 'RGB_rendering.jpeg':
+            if file_grape_arr == "RGB_rendering.jpeg":
                 continue
 
-            if file_grape_arr == 'rectangular_labels.txt':
+            if file_grape_arr == "rectangular_labels.txt":
                 continue
 
             else:
                 # Extract pixel id based off name of the file. We want the number between _ and .
 
-                pixel_id_tmp = int(file_grape_arr.split('_')[1].split('.')[0])
+                pixel_id_tmp = int(file_grape_arr.split("_")[1].split(".")[0])
                 # print(pixel_id_tmp)
 
                 # Load bounding box coordinates from file
-                bbox_tmp = np.loadtxt(frames_view_path + file_grape_arr, max_rows = 1)
+                bbox_tmp = np.loadtxt(frames_view_path + file_grape_arr, max_rows=1)
                 bbox_tmp = [int(bbox_tmp[i]) for i in range(0, 4)]
                 bbox = np.copy(bbox_tmp)
                 bbox[3] = render_xy_shape[0] - bbox_tmp[2]
@@ -717,12 +744,12 @@ def generate_npy_arr(self, Frames_path, frames_view_path):
                 # print(bbox_tmp)
 
                 # Load pixel positions from file
-                grape_arr_tmp = np.loadtxt(frames_view_path + file_grape_arr, skiprows = 1, ndmin = 2)
+                grape_arr_tmp = np.loadtxt(frames_view_path + file_grape_arr, skiprows=1, ndmin=2)
 
                 #
-                grape_arr_tmp = (grape_arr_tmp == pixel_id_tmp)
+                grape_arr_tmp = grape_arr_tmp == pixel_id_tmp
 
-                npy_arr[bbox[2]:(bbox[3] + 1), bbox[0]:(bbox[1] + 1), i] = grape_arr_tmp
+                npy_arr[bbox[2] : (bbox[3] + 1), bbox[0] : (bbox[1] + 1), i] = grape_arr_tmp
 
                 i += 1
 
diff --git a/agml/_internal/utils.py b/agml/_internal/utils.py
index 56e128a0..fd7a5751 100644
--- a/agml/_internal/utils.py
+++ b/agml/_internal/utils.py
@@ -21,12 +21,14 @@
 
 from agml.utils.io import recursive_dirname
 
-
 _PERSONAL_ACCESS_TOKEN = None
 
 
 def shape_info_file_contents():
-    with open(os.path.join(recursive_dirname(__file__, 2), '_assets', 'shape_info.pickle'), 'rb') as f:
+    with open(
+        os.path.join(recursive_dirname(__file__, 2), "_assets", "shape_info.pickle"),
+        "rb",
+    ) as f:
         return pickle.load(f)
 
 
diff --git a/agml/backend/__init__.py b/agml/backend/__init__.py
index 7173897d..c60fa334 100644
--- a/agml/backend/__init__.py
+++ b/agml/backend/__init__.py
@@ -24,16 +24,16 @@
 AgML, specifically data loaded or generated from the data module.
 """
 
+from . import experimental
 from .config import (
+    clear_all_datasets,
     data_save_path,
-    set_data_save_path,
-    synthetic_data_save_path,
-    set_synthetic_save_path,
+    downloaded_datasets,
     model_save_path,
+    set_data_save_path,
     set_model_save_path,
-    clear_all_datasets,
-    downloaded_datasets
+    set_synthetic_save_path,
+    synthetic_data_save_path,
 )
-from .tftorch import get_backend, set_backend
 from .random import set_seed
-from . import experimental
+from .tftorch import get_backend, set_backend
diff --git a/agml/backend/config.py b/agml/backend/config.py
index 2d0d02d8..0fd3d471 100644
--- a/agml/backend/config.py
+++ b/agml/backend/config.py
@@ -12,20 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import json
-import shutil
 import logging
+import os
+import shutil
 
 from agml.utils.logging import log
 
-
 # The super base save directory for AgML. This is the overriding base
 # save directory and default original save directory. This is saved here
 # because the default path to save datasets to can be overridden by
 # `set_dataset_save_path()`, but we need to keep the super directory to
 # access the config file which stores this information in the first place.
-SUPER_BASE_DIR = os.path.join(os.path.expanduser('~'), '.agml')
+SUPER_BASE_DIR = os.path.join(os.path.expanduser("~"), ".agml")
 
 
 # This is the path to the saved datasets. By default, this saves to
@@ -52,18 +51,24 @@
 def _load_config_info():
     global DATASET_SAVE_DIR, SYNTHETIC_SAVE_DIR, MODEL_SAVE_DIR
     try:
-        with open(os.path.join(SUPER_BASE_DIR, 'config.json'), 'r') as f:
+        with open(os.path.join(SUPER_BASE_DIR, "config.json"), "r") as f:
             contents = json.load(f)
-            DATASET_SAVE_DIR = contents['data_path']
-            SYNTHETIC_SAVE_DIR = contents['synthetic_data_path']
-            MODEL_SAVE_DIR = contents['model_path']
+            DATASET_SAVE_DIR = contents["data_path"]
+            SYNTHETIC_SAVE_DIR = contents["synthetic_data_path"]
+            MODEL_SAVE_DIR = contents["model_path"]
     except (OSError, KeyError):
-        with open(os.path.join(SUPER_BASE_DIR, 'config.json'), 'w') as f:
-            json.dump({'data_path': os.path.join(SUPER_BASE_DIR, 'datasets'),
-                       'synthetic_data_path': os.path.join(
-                           SUPER_BASE_DIR, 'synthetic'),
-                       'model_path': os.path.join(SUPER_BASE_DIR, 'models')}, f)
+        with open(os.path.join(SUPER_BASE_DIR, "config.json"), "w") as f:
+            json.dump(
+                {
+                    "data_path": os.path.join(SUPER_BASE_DIR, "datasets"),
+                    "synthetic_data_path": os.path.join(SUPER_BASE_DIR, "synthetic"),
+                    "model_path": os.path.join(SUPER_BASE_DIR, "models"),
+                },
+                f,
+            )
         _load_config_info()
+
+
 _load_config_info()
 
 
@@ -73,7 +78,7 @@ def data_save_path():
     return DATASET_SAVE_DIR
 
 
-def set_data_save_path(location = None):
+def set_data_save_path(location=None):
     """Sets the default dataset save path for AgML.
     Changing the data save path using this method permanently changes
     the data save path for all future sessions, until it is changed
@@ -88,14 +93,12 @@ def set_data_save_path(location = None):
     The fully expanded location.
     """
     global SUPER_BASE_DIR
-    if location is None or location == 'reset':
-        location = os.path.join(SUPER_BASE_DIR, 'datasets')
+    if location is None or location == "reset":
+        location = os.path.join(SUPER_BASE_DIR, "datasets")
     location = os.path.expanduser(location)
     if not os.path.exists(location) and not os.path.isdir(location):
-        raise NotADirectoryError(
-            f"The provided destination {location} does "
-            f"not exist, or is not a directory.")
-    _update_config('data_path', os.path.realpath(os.path.abspath(location)))
+        raise NotADirectoryError(f"The provided destination {location} does " f"not exist, or is not a directory.")
+    _update_config("data_path", os.path.realpath(os.path.abspath(location)))
     return
 
 
@@ -105,7 +108,7 @@ def synthetic_data_save_path():
     return SYNTHETIC_SAVE_DIR
 
 
-def set_synthetic_save_path(location = None):
+def set_synthetic_save_path(location=None):
     """Sets the default synthetic data save path for AgML.
     Changing the data save path using this method permanently changes
     the data save path for all future sessions, until it is changed
@@ -120,14 +123,12 @@ def set_synthetic_save_path(location = None):
     The fully expanded location.
     """
     global SUPER_BASE_DIR
-    if location is None or location == 'reset':
-        location = os.path.join(SUPER_BASE_DIR, 'synthetic')
+    if location is None or location == "reset":
+        location = os.path.join(SUPER_BASE_DIR, "synthetic")
     location = os.path.expanduser(location)
     if not os.path.exists(location) and not os.path.isdir(location):
-        raise NotADirectoryError(
-            f"The provided destination {location} does "
-            f"not exist, or is not a directory.")
-    _update_config('synthetic_data_path', os.path.realpath(os.path.abspath(location)))
+        raise NotADirectoryError(f"The provided destination {location} does " f"not exist, or is not a directory.")
+    _update_config("synthetic_data_path", os.path.realpath(os.path.abspath(location)))
     return
 
 
@@ -137,7 +138,7 @@ def model_save_path():
     return MODEL_SAVE_DIR
 
 
-def set_model_save_path(location = None):
+def set_model_save_path(location=None):
     """Sets the default model save path for AgML.
     Changing the data save path using this method permanently changes
     the data save path for all future sessions, until it is changed
@@ -151,21 +152,19 @@ def set_model_save_path(location = None):
     The fully expanded location.
     """
     global SUPER_BASE_DIR
-    if location is None or location == 'reset':
-        location = os.path.join(SUPER_BASE_DIR, 'models')
+    if location is None or location == "reset":
+        location = os.path.join(SUPER_BASE_DIR, "models")
     location = os.path.expanduser(location)
     if not os.path.exists(location) and not os.path.isdir(location):
-        raise NotADirectoryError(
-            f"The provided destination {location} does "
-            f"not exist, or is not a directory.")
-    _update_config('model_path', os.path.realpath(os.path.abspath(location)))
+        raise NotADirectoryError(f"The provided destination {location} does " f"not exist, or is not a directory.")
+    _update_config("model_path", os.path.realpath(os.path.abspath(location)))
     return
 
 
 def _get_config(param):
     """Update the configuration file with a new parameter."""
     global SUPER_BASE_DIR
-    with open(os.path.join(SUPER_BASE_DIR, 'config.json'), 'r') as f:
+    with open(os.path.join(SUPER_BASE_DIR, "config.json"), "r") as f:
         contents = json.load(f)
     if param not in contents.keys():
         return None
@@ -175,28 +174,25 @@ def _get_config(param):
 def _update_config(param, value):
     """Update the configuration file with a new parameter."""
     global SUPER_BASE_DIR
-    with open(os.path.join(SUPER_BASE_DIR, 'config.json'), 'r') as f:
+    with open(os.path.join(SUPER_BASE_DIR, "config.json"), "r") as f:
         contents = json.load(f)
     contents[param] = value
-    with open(os.path.join(SUPER_BASE_DIR, 'config.json'), 'w') as f:
+    with open(os.path.join(SUPER_BASE_DIR, "config.json"), "w") as f:
         json.dump(contents, f)
 
 
 def clear_all_datasets():
     """Deletes all of the datasets within the AgML local storage."""
     log("Entering AgML interactive dataset deletion mode.", logging.WARNING)
-    msg_format = '\033[91m{0}\033[0m'
-    if not input(msg_format.format(
-            "Please confirm that you want to delete datasets: [y|n] ")) == "y":
+    msg_format = "\033[91m{0}\033[0m"
+    if not input(msg_format.format("Please confirm that you want to delete datasets: [y|n] ")) == "y":
         print("Aborting dataset deletion.")
     local_datasets = os.listdir(data_save_path())
     deleted_datasets = []
     for dataset in local_datasets:
-        if not os.path.isdir(os.path.join(
-                data_save_path(), dataset)):
+        if not os.path.isdir(os.path.join(data_save_path(), dataset)):
             continue
-        if not input(msg_format.format(
-                f"Delete dataset '{dataset}'? [y|n] ")) == "y":
+        if not input(msg_format.format(f"Delete dataset '{dataset}'? [y|n] ")) == "y":
             continue
         shutil.rmtree(os.path.join(data_save_path(), dataset))
         deleted_datasets.append(dataset)
@@ -206,6 +202,4 @@ def clear_all_datasets():
 
 def downloaded_datasets():
     """Lists downloaded datasets in ~/.agml/datasets"""
-    return [d for d in os.listdir(
-        data_save_path()) if os.path.isdir(
-        os.path.join(data_save_path(), d))]
\ No newline at end of file
+    return [d for d in os.listdir(data_save_path()) if os.path.isdir(os.path.join(data_save_path(), d))]
diff --git a/agml/backend/experimental.py b/agml/backend/experimental.py
index 5de1f616..3cc23971 100644
--- a/agml/backend/experimental.py
+++ b/agml/backend/experimental.py
@@ -15,12 +15,12 @@
 
 from agml.framework import AgMLSerializable
 
-
-__all__ = ['allow_nested_data_splitting']
+__all__ = ["allow_nested_data_splitting"]
 
 
 class AgMLExperimentalFeatureWrapper(AgMLSerializable):
     """Stores all of the feature values."""
+
     _NESTED_SPLITTING = False
 
     def __init__(self):
@@ -58,4 +58,3 @@ def nested_splitting(cls):
 # While the `AgMLExperimentalFeatureWrapper` class controls the actual values,
 # we expose each of its toggle methods as part of the `agml.backend` API.
 allow_nested_data_splitting = AgMLExperimentalFeatureWrapper.allow_nested_data_splitting
-
diff --git a/agml/backend/random.py b/agml/backend/random.py
index 10acf140..ac1ab52e 100644
--- a/agml/backend/random.py
+++ b/agml/backend/random.py
@@ -12,17 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from agml.backend.tftorch import torch, tf, get_backend
+from agml.backend.tftorch import get_backend, tf, torch
 
 
-def set_seed(seed = None):
+def set_seed(seed=None):
     """Sets a new random seed. If None, uses a random seed."""
     import random
+
     random.seed(seed)
     import numpy as np
+
     np.random.seed(seed)
-    if get_backend() == 'torch':
+    if get_backend() == "torch":
         torch.random.manual_seed(seed)
-    elif get_backend() == 'tensorflow':
+    elif get_backend() == "tensorflow":
         tf.random.set_seed(seed)
-
diff --git a/agml/backend/tftorch.py b/agml/backend/tftorch.py
index 1962223d..ae34cbc5 100644
--- a/agml/backend/tftorch.py
+++ b/agml/backend/tftorch.py
@@ -17,30 +17,32 @@
 TensorFlow or PyTorch methods can be used, and prevents unnecessary
 importing of either library (which takes a significant amount of time).
 """
-import types
+
+import functools
+import importlib
 import inspect
 import logging
-import importlib
-import functools
+import types
+
+# Suppress any irrelevant warnings which will pop up from either backend.
+import warnings
 
 import numpy as np
 
-from agml.utils.logging import log
 from agml.utils.image import consistent_shapes
+from agml.utils.logging import log
 
-
-# Suppress any irrelevant warnings which will pop up from either backend.
-import warnings
-warnings.filterwarnings(
-    'ignore', category = UserWarning, message = '.*Named tensors.*Triggered internally.*')
+warnings.filterwarnings("ignore", category=UserWarning, message=".*Named tensors.*Triggered internally.*")
 
 
 class StrictBackendError(ValueError):
-    def __init__(self, message = None, change = None, obj = None):
+    def __init__(self, message=None, change=None, obj=None):
         if message is None:
-            message = f"Backend was manually set to " \
-                      f"'{get_backend()}', but got an object " \
-                      f"from backend '{change}': {obj}."
+            message = (
+                f"Backend was manually set to "
+                f"'{get_backend()}', but got an object "
+                f"from backend '{change}': {obj}."
+            )
         super(StrictBackendError, self).__init__(message)
 
 
@@ -49,7 +51,7 @@ def __init__(self, message = None, change = None, obj = None):
 _HAS_TORCH: bool
 
 
-@functools.lru_cache(maxsize = None)
+@functools.lru_cache(maxsize=None)
 def _check_tf_torch():
     global _HAS_TENSORFLOW, _HAS_TORCH
     try:
@@ -90,9 +92,9 @@ def set_backend(backend):
     global _USER_SET_BACKEND, _BACKEND
     # Check whether the user has modified the backend.
     mod = inspect.getmodule(inspect.stack()[1][0])
-    if mod is None: # IPython shell
+    if mod is None:  # IPython shell
         _USER_SET_BACKEND = True
-    elif 'agml.' not in mod.__name__:
+    elif "agml." not in mod.__name__:
         _USER_SET_BACKEND = True
 
     # If the backend is the same, don't do anything.
@@ -100,22 +102,22 @@ def set_backend(backend):
         return
 
     _check_tf_torch()
-    if backend not in ['tensorflow', 'tf', 'torch', 'pytorch']:
+    if backend not in ["tensorflow", "tf", "torch", "pytorch"]:
         raise ValueError(f"Invalid backend: {backend}.")
-    if backend in ['tensorflow', 'tf'] and _BACKEND != 'tensorflow':
+    if backend in ["tensorflow", "tf"] and _BACKEND != "tensorflow":
         if not _HAS_TENSORFLOW:
             raise ImportError(
-                "TensorFlow not found on system, cannot be used as "
-                "backend. Try running `pip install tensorflow`.")
-        _BACKEND = 'tf'
-        log("Switched backend to TensorFlow.", level = logging.INFO)
-    elif backend in ['torch', 'pytorch'] and _BACKEND != 'torch':
+                "TensorFlow not found on system, cannot be used as " "backend. Try running `pip install tensorflow`."
+            )
+        _BACKEND = "tf"
+        log("Switched backend to TensorFlow.", level=logging.INFO)
+    elif backend in ["torch", "pytorch"] and _BACKEND != "torch":
         if not _HAS_TORCH:
             raise ImportError(
-                "PyTorch not found on system, cannot be used as "
-                "backend. Try running `pip install torch`.")
-        _BACKEND = 'torch'
-        log("Switched backend to PyTorch.", level = logging.INFO)
+                "PyTorch not found on system, cannot be used as " "backend. Try running `pip install torch`."
+            )
+        _BACKEND = "torch"
+        log("Switched backend to PyTorch.", level=logging.INFO)
 
 
 def user_changed_backend():
@@ -125,42 +127,44 @@ def user_changed_backend():
 
 # Ported from https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/util/lazy_loader.py
 class LazyLoader(types.ModuleType):
-  """Lazily import a module, mainly to avoid pulling in large dependencies.  """
-  def __init__(self, local_name, parent_module_globals, name):
-    self._local_name = local_name
-    self._parent_module_globals = parent_module_globals
-    super(LazyLoader, self).__init__(name)
+    """Lazily import a module, mainly to avoid pulling in large dependencies."""
+
+    def __init__(self, local_name, parent_module_globals, name):
+        self._local_name = local_name
+        self._parent_module_globals = parent_module_globals
+        super(LazyLoader, self).__init__(name)
 
-  def _load(self):
-    """Load the module and insert it into the parent's globals."""
-    # Import the target module and insert it into the parent's namespace.
-    module = importlib.import_module(self.__name__)
-    self._parent_module_globals[self._local_name] = module
+    def _load(self):
+        """Load the module and insert it into the parent's globals."""
+        # Import the target module and insert it into the parent's namespace.
+        module = importlib.import_module(self.__name__)
+        self._parent_module_globals[self._local_name] = module
 
-    # Update this object's dict so that if someone keeps a reference to the
-    #   LazyLoader, lookups are efficient (__getattr__ is only called on lookups
-    #   that fail).
-    self.__dict__.update(module.__dict__)
-    return module
+        # Update this object's dict so that if someone keeps a reference to the
+        #   LazyLoader, lookups are efficient (__getattr__ is only called on lookups
+        #   that fail).
+        self.__dict__.update(module.__dict__)
+        return module
 
-  def __getattr__(self, item):
-    module = self._load()
-    return getattr(module, item)
+    def __getattr__(self, item):
+        module = self._load()
+        return getattr(module, item)
 
-  def __dir__(self):
-    module = self._load()
-    return dir(module)
+    def __dir__(self):
+        module = self._load()
+        return dir(module)
 
 
 # Load TensorFlow and PyTorch lazily to prevent pulling them in when unnecessary.
-torch = LazyLoader('torch', globals(), 'torch')
-torch_data = LazyLoader('torch_data', globals(), 'torch.utils.data')
-torchvision = LazyLoader('torchvision', globals(), 'torchvision')
-tf = LazyLoader('tensorflow', globals(), 'tensorflow')
+torch = LazyLoader("torch", globals(), "torch")
+torch_data = LazyLoader("torch_data", globals(), "torch.utils.data")
+torchvision = LazyLoader("torchvision", globals(), "torchvision")
+tf = LazyLoader("tensorflow", globals(), "tensorflow")
 
 
 ######### GENERAL METHODS #########
 
+
 def _convert_image_to_torch(image):
     """Converts an image (np.ndarray) to a torch Tensor."""
     if isinstance(image, (list, tuple)):
@@ -207,9 +211,9 @@ def scalar_unpack(inp):
     return [as_scalar(item) for item in inp]
 
 
-def is_array_like(inp, no_list = False):
+def is_array_like(inp, no_list=False):
     """Determines if an input is a np.ndarray, torch.Tensor, or tf.Tensor."""
-    if isinstance(inp, (list, tuple)): # no need to import tensorflow for this
+    if isinstance(inp, (list, tuple)):  # no need to import tensorflow for this
         if no_list:
             return False
         return True
@@ -231,10 +235,12 @@ def convert_to_batch(images):
     # NumPy Arrays.
     if isinstance(images[0], np.ndarray):
         if not consistent_shapes(images):
-            images = np.array(images, dtype = object)
-            log("Created a batch of images with different "
+            images = np.array(images, dtype=object)
+            log(
+                "Created a batch of images with different "
                 "shapes. If you want the shapes to be consistent, "
-                "run `loader.resize_images('auto')`.")
+                "run `loader.resize_images('auto')`."
+            )
         else:
             images = np.array(images)
         return images
@@ -243,10 +249,12 @@ def convert_to_batch(images):
     if isinstance(images[0], torch.Tensor):
         if not consistent_shapes(images):
             images = [image.numpy() for image in images]
-            images = np.array(images, dtype = object)
-            log("Created a batch of images with different "
+            images = np.array(images, dtype=object)
+            log(
+                "Created a batch of images with different "
                 "shapes. If you want the shapes to be consistent, "
-                "run `loader.resize_images('auto')`.")
+                "run `loader.resize_images('auto')`."
+            )
         else:
             images = torch.stack(images)
         return images
@@ -255,9 +263,11 @@ def convert_to_batch(images):
     if isinstance(images[0], tf.Tensor):
         if not consistent_shapes(images):
             images = tf.ragged.stack(images)
-            log("Created a batch of images with different "
+            log(
+                "Created a batch of images with different "
                 "shapes. If you want the shapes to be consistent, "
-                "run `loader.resize_images('auto')`.")
+                "run `loader.resize_images('auto')`."
+            )
         else:
             images = tf.stack(images)
         return images
@@ -265,6 +275,7 @@ def convert_to_batch(images):
 
 ######### AGMLDATALOADER METHODS #########
 
+
 class AgMLObject(object):
     """Base class for the `AgMLDataLoader` to enable inheritance.
 
@@ -282,23 +293,23 @@ def _add_dataset_to_mro(inst, mode):
     This allows for the loader to dynamically inherent from the
     `tf.keras.utils.Sequence` and `torch.utils.data.Dataset`.
     """
-    if mode == 'tf':
-        if not get_backend() == 'tf':
+    if mode == "tf":
+        if not get_backend() == "tf":
             if user_changed_backend():
-                raise StrictBackendError(change = 'tf', obj = inst)
-            set_backend('tf')
+                raise StrictBackendError(change="tf", obj=inst)
+            set_backend("tf")
         if tf.keras.utils.Sequence not in inst.__class__.__bases__:
-            inst.__class__.__bases__ += (tf.keras.utils.Sequence, )
-    if mode == 'torch':
-        if not get_backend() == 'torch':
+            inst.__class__.__bases__ += (tf.keras.utils.Sequence,)
+    if mode == "torch":
+        if not get_backend() == "torch":
             if user_changed_backend():
-                raise StrictBackendError(change = 'torch', obj = inst)
+                raise StrictBackendError(change="torch", obj=inst)
         if torch_data.Dataset not in inst.__class__.__bases__:
             inst.__class__.__bases__ += (torch_data.Dataset,)
 
 
 def collate_fn_basic(batch):
-    images = torch.stack([i[0] for i in batch], dim = 0)
+    images = torch.stack([i[0] for i in batch], dim=0)
     coco = tuple(zip(*[i[1] for i in batch]))
     return images, coco
 
@@ -315,6 +326,9 @@ def collate_fn_efficientdet(batch):
     img_scale = torch.stack([target["img_scale"] for target in targets]).float()
 
     annotations = {
-        "bbox": boxes, "cls": labels,
-        "img_size": img_size, "img_scale": img_scale}
+        "bbox": boxes,
+        "cls": labels,
+        "img_size": img_size,
+        "img_scale": img_scale,
+    }
     return images, annotations, targets
diff --git a/agml/data/__init__.py b/agml/data/__init__.py
index 43c20e0c..a1c729c3 100644
--- a/agml/data/__init__.py
+++ b/agml/data/__init__.py
@@ -12,16 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .loader import AgMLDataLoader
+from . import experimental, exporters, extensions
 from .image_loader import ImageLoader
+from .loader import AgMLDataLoader
 from .point_cloud import PointCloud
-from .public import (
-    public_data_sources, source
-)
-from .public import download_public_dataset
-from .tools import (
-    coco_to_bboxes, convert_bbox_format
-)
-from . import experimental
-from . import exporters
-from . import extensions
+from .public import download_public_dataset, public_data_sources, source
+from .tools import coco_to_bboxes, convert_bbox_format
diff --git a/agml/data/builder.py b/agml/data/builder.py
index 247007ab..fa98a9b5 100644
--- a/agml/data/builder.py
+++ b/agml/data/builder.py
@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import os
 import re
 import sys
-import json
 
-from agml.framework import AgMLSerializable
 from agml.backend.config import data_save_path
+from agml.framework import AgMLSerializable
 from agml.utils.downloads import download_dataset
-from agml.utils.io import get_file_list, get_dir_list, is_image_file
+from agml.utils.io import get_dir_list, get_file_list, is_image_file
 
 
 class DataBuilder(AgMLSerializable):
@@ -36,22 +36,20 @@ class DataBuilder(AgMLSerializable):
     it creates a mapping between the images and annotations which is
     used by the `DataManager` inside the `AgMLDataLoader`.
     """
-    serializable = frozenset(
-        ('name', 'labels_for_image', 'data',
-         'info', 'dataset_root', 'data_length'))
+
+    serializable = frozenset(("name", "labels_for_image", "data", "info", "dataset_root", "data_length"))
 
     def __init__(self, info, dataset_path, overwrite):
         # Attempt to locate or download the dataset.
         self._info = info
         self._name = info.name
-        self._configure_dataset(
-            dataset_path = dataset_path, overwrite = overwrite)
+        self._configure_dataset(dataset_path=dataset_path, overwrite=overwrite)
         self._data = None
         self._data_length = None
         self._labels_for_image = None
 
     @classmethod
-    def from_data(cls, contents, info, root, builder = None):
+    def from_data(cls, contents, info, root, builder=None):
         """Initializes the `DataBuilder` from a pre-built set of data.
 
         This is mainly used when running `AgMLDataLoader.split`, to create
@@ -67,9 +65,10 @@ def from_data(cls, contents, info, root, builder = None):
         obj._data_length = len(obj._data)
         obj._labels_for_image = contents[1]
         if builder is not None:
-            if hasattr(builder, '_default_coco_annotations'):
+            if hasattr(builder, "_default_coco_annotations"):
                 obj._default_coco_annotations = DataBuilder._regenerate_coco_annotations(
-                    builder._default_coco_annotations, obj._data)
+                    builder._default_coco_annotations, obj._data
+                )
         return obj
 
     @staticmethod
@@ -80,22 +79,22 @@ def _regenerate_coco_annotations(coco, data):
         image_id_tracker = 0
 
         # Update the list of image paths.
-        for c in coco['images']:
-            if c['file_name'] in list(data.keys()):
-                c['image_id'] = image_id_tracker
+        for c in coco["images"]:
+            if c["file_name"] in list(data.keys()):
+                c["image_id"] = image_id_tracker
                 image_coco.append(c)
                 image_id_tracker += 1
 
         # Update the image IDs for the annotations
         for image_id, (_, annotation) in enumerate(data.items()):
             for a in annotation:
-                a['id'] = image_id
+                a["id"] = image_id
             annotation_coco.extend(annotation)
 
         # Update the complete COCO dictionary.
         ret_coco = coco.copy()
-        ret_coco['images'] = image_coco
-        ret_coco['annotations'] = annotation_coco
+        ret_coco["images"] = image_coco
+        ret_coco["annotations"] = annotation_coco
         return ret_coco
 
     @property
@@ -106,10 +105,9 @@ def _configure_dataset(self, **kwargs):
         """Finds and configures the dataset into the loader."""
         # Check if the user wants to overwrite the existing dataset,
         # and resolve the potentially provided custom dataset path.
-        overwrite = kwargs.get('overwrite', False)
-        if kwargs.get('dataset_path', None):
-            kwargs['dataset_path'] = os.path.realpath(
-                os.path.expanduser(kwargs['dataset_path']))
+        overwrite = kwargs.get("overwrite", False)
+        if kwargs.get("dataset_path", None):
+            kwargs["dataset_path"] = os.path.realpath(os.path.expanduser(kwargs["dataset_path"]))
 
         # If a custom dataset has been provided, then we assume the directory
         # provided is the root of the dataset, e.g., if /root/datasets/dir
@@ -120,22 +118,21 @@ def _configure_dataset(self, **kwargs):
         #
         # No downloading phase for custom datasets, as there is nothing to do.
         if self._info.is_custom_dataset:
-            if kwargs.get('dataset_path', False):
-                path = kwargs.get('dataset_path')
+            if kwargs.get("dataset_path", False):
+                path = kwargs.get("dataset_path")
                 if os.path.exists(path):
                     self._dataset_root = path
                     return
 
-            elif os.path.exists(os.path.join(
-                    data_save_path(), self._name)):
-                self._dataset_root = os.path.join(
-                    data_save_path(), self._name)
+            elif os.path.exists(os.path.join(data_save_path(), self._name)):
+                self._dataset_root = os.path.join(data_save_path(), self._name)
                 return
 
             # Otherwise, we don't know what to do.
             raise OSError(
                 f"Could not find a directory for the dataset {self._name}. "
-                f"Dataset path given: {kwargs.get('dataset_path', None)}")
+                f"Dataset path given: {kwargs.get('dataset_path', None)}"
+            )
 
         # If the user doesn't want to overwrite the existing contents,
         # first check whether the dataset already exists. If so, then set
@@ -146,57 +143,48 @@ def _configure_dataset(self, **kwargs):
         # then we pop '<name>' from the end of the path in order to prevent
         # the dataset from being downloaded to `/root/datasets/<name>/<name>`.
         if not overwrite:
-            if kwargs.get('dataset_path', False):
-                path = kwargs.get('dataset_path')
-                if (os.path.basename(path) == self._name
-                    and os.path.exists(path)) or \
-                        os.path.exists(os.path.join(path, self._name)):
+            if kwargs.get("dataset_path", False):
+                path = kwargs.get("dataset_path")
+                if (os.path.basename(path) == self._name and os.path.exists(path)) or os.path.exists(
+                    os.path.join(path, self._name)
+                ):
                     if os.path.basename(path) != self._name:
                         path = os.path.join(path, self._name)
                     self._dataset_root = path
                     return
 
-            elif os.path.exists(os.path.join(
-                    data_save_path(), self._name)):
-                self._dataset_root = os.path.join(
-                    data_save_path(), self._name)
+            elif os.path.exists(os.path.join(data_save_path(), self._name)):
+                self._dataset_root = os.path.join(data_save_path(), self._name)
                 return
 
         # If the user wants to overwrite, or the dataset doesn't exist
         # at the path, then we create the root in the same way, except
         # we just also download the dataset to the path.
         else:
-            if kwargs.get('dataset_path', False):
-                path = kwargs.get('dataset_path')
-                if (os.path.basename(path) == self._name
-                    and os.path.exists(path)) or \
-                        os.path.exists(os.path.join(path, self._name)):
+            if kwargs.get("dataset_path", False):
+                path = kwargs.get("dataset_path")
+                if (os.path.basename(path) == self._name and os.path.exists(path)) or os.path.exists(
+                    os.path.join(path, self._name)
+                ):
                     if os.path.basename(path) != self._name:
                         path = os.path.join(path, self._name)
-                    print(f'[AgML Download]: Overwriting dataset at '
-                          f'{os.path.join(path)}')
+                    print(f"[AgML Download]: Overwriting dataset at " f"{os.path.join(path)}")
                     if os.path.basename(path) != self._name:
                         path = os.path.join(path, self._name)
                     self._dataset_root = path
 
-            elif os.path.exists(os.path.join(
-                    data_save_path(), self._name)):
-                self._dataset_root = os.path.join(
-                    data_save_path(), self._name)
-                sys.stderr.write(
-                    f'[AgML Download]: Overwriting dataset at '
-                    f'{os.path.join(self._dataset_root)}')
+            elif os.path.exists(os.path.join(data_save_path(), self._name)):
+                self._dataset_root = os.path.join(data_save_path(), self._name)
+                sys.stderr.write(f"[AgML Download]: Overwriting dataset at " f"{os.path.join(self._dataset_root)}")
 
         # Performs the actual downloading of the dataset.
-        if kwargs.get('dataset_path', False):
-            download_path = kwargs['dataset_path']
+        if kwargs.get("dataset_path", False):
+            download_path = kwargs["dataset_path"]
             if os.path.basename(download_path) != self._name:
                 download_path = os.path.join(download_path, self._name)
         else:
             download_path = os.path.join(data_save_path(), self._name)
-        sys.stderr.write(
-            f"[AgML Download]: Downloading dataset "
-            f"`{self._name}` to {download_path}.")
+        sys.stderr.write(f"[AgML Download]: Downloading dataset " f"`{self._name}` to {download_path}.")
         download_dataset(self._name, download_path)
         self._dataset_root = download_path
 
@@ -204,11 +192,11 @@ def _generate_contents(self, task):
         """Dispatches to a content generation method for the provided task."""
         if self._data is not None:
             return
-        if task == 'image_classification':
+        if task == "image_classification":
             self._generate_image_classification_data()
-        elif task == 'image_regression':
+        elif task == "image_regression":
             self._generate_image_regression_data()
-        elif task == 'object_detection':
+        elif task == "object_detection":
             self._generate_object_detection_data()
         else:
             self._generate_semantic_segmentation_data()
@@ -221,8 +209,8 @@ def get_contents(self):
         # Update the length of the data in the metadata dictionary for
         # custom datasets, since they may not be providing the total number.
         self._data_length = len(self._data)
-        if self._info._metadata.get('n_images', None) is None:
-            self._info._metadata['n_images'] = str(self._data_length)
+        if self._info._metadata.get("n_images", None) is None:
+            self._info._metadata["n_images"] = str(self._data_length)
         return self._data
 
     def export_contents(self, export_format):
@@ -231,10 +219,9 @@ def export_contents(self, export_format):
         contents = self.get_contents()
 
         # For a COCO JSON dictionary, we have to make the full paths.
-        if self._info.tasks.ml == 'object_detection':
+        if self._info.tasks.ml == "object_detection":
             paths, coco = contents.keys(), contents.values()
-            paths = [os.path.join(
-                self._dataset_root, 'images', i) for i in paths]
+            paths = [os.path.join(self._dataset_root, "images", i) for i in paths]
             contents = dict({k: v for k, v in zip(paths, coco)})
 
         # If the export format is `None`, we return the default mapping.
@@ -243,14 +230,13 @@ def export_contents(self, export_format):
 
         # If the export format is `arrays`, return the keys and
         # the values of the mapping as two independent arrays.
-        if export_format == 'arrays':
+        if export_format == "arrays":
             return list(contents.keys()), list(contents.values())
 
         # A special case for COCO JSON dictionaries.
-        if export_format == 'coco':
-            if self._info.tasks.ml != 'object_detection':
-                raise ValueError("The `coco` export format is "
-                                 "only for object detection tasks.")
+        if export_format == "coco":
+            if self._info.tasks.ml != "object_detection":
+                raise ValueError("The `coco` export format is " "only for object detection tasks.")
             return self._default_coco_annotations
 
     # The following methods actually generate the content mappings for
@@ -268,7 +254,7 @@ def _generate_image_classification_data(self):
         image_label_mapping = {}
         candidate_dirs = get_dir_list(self._dataset_root)
         for dir_ in candidate_dirs:
-            if dir_.startswith('.'):
+            if dir_.startswith("."):
                 continue
             dir_path = os.path.join(self._dataset_root, dir_)
             if len(get_file_list(dir_path)) == 0:
@@ -285,23 +271,21 @@ def _generate_image_regression_data(self):
         well as other image formats in other various `*_images` folders,
         and an `annotations.json` file containing the regression outputs.
         """
-        with open(os.path.join(self._dataset_root, 'annotations.json'), 'r') as f:
+        with open(os.path.join(self._dataset_root, "annotations.json"), "r") as f:
             annotations = json.load(f)
-        content_mapping = {'inputs': [], 'outputs': []}
+        content_mapping = {"inputs": [], "outputs": []}
         annotation_types = set(list(self._info.class_to_num.keys()))
-        annotation_types.remove('regression')
+        annotation_types.remove("regression")
         for sample in annotations:
             for k, v in sample.items():
                 if is_image_file(v):
-                    sample[k] = os.path.join(self._dataset_root, f'{k}s', v)
-            content_mapping['inputs'].append({
-                k: v for k, v in sample.items()
-                if re.match('(.*?)image', k)})
-            out = {'regression': list(sample['outputs']['regression'].values())}
-            out.update({
-                k: self._info.class_to_num[k][v] for k, v in sample['outputs'].items()
-                if k in annotation_types})
-            content_mapping['outputs'].append(out)
+                    sample[k] = os.path.join(self._dataset_root, f"{k}s", v)
+            content_mapping["inputs"].append({k: v for k, v in sample.items() if re.match("(.*?)image", k)})
+            out = {"regression": list(sample["outputs"]["regression"].values())}
+            out.update(
+                {k: self._info.class_to_num[k][v] for k, v in sample["outputs"].items() if k in annotation_types}
+            )
+            content_mapping["outputs"].append(out)
         self._data = content_mapping
 
     def _generate_semantic_segmentation_data(self):
@@ -310,14 +294,15 @@ def _generate_semantic_segmentation_data(self):
         Image data is loaded from an `images` directory, and pixel-wise
         annotated images are loaded from an `annotations` directory.
         """
-        image_dir = os.path.join(self._dataset_root, 'images')
-        annotation_dir = os.path.join(self._dataset_root, 'annotations')
-        images, annotations = sorted(get_file_list(image_dir)), \
-                              sorted(get_file_list(annotation_dir))
+        image_dir = os.path.join(self._dataset_root, "images")
+        annotation_dir = os.path.join(self._dataset_root, "annotations")
+        images, annotations = (
+            sorted(get_file_list(image_dir)),
+            sorted(get_file_list(annotation_dir)),
+        )
         image_annotation_map = {}
         for image_path, annotation_path in zip(images, annotations):
-            image_annotation_map[os.path.join(image_dir, image_path)] \
-                = os.path.join(annotation_dir, annotation_path)
+            image_annotation_map[os.path.join(image_dir, image_path)] = os.path.join(annotation_dir, annotation_path)
         self._data = image_annotation_map
 
     def _generate_object_detection_data(self):
@@ -326,18 +311,16 @@ def _generate_object_detection_data(self):
         Image data is loaded from an `images` directory, and the COCO
         JSON annotations are loaded from an `annotations.json` file.
         """
-        with open(os.path.join(self._dataset_root, 'annotations.json')) as f:
+        with open(os.path.join(self._dataset_root, "annotations.json")) as f:
             self._default_coco_annotations = json.load(f)
         coco_annotations = self._default_coco_annotations
         image_id_mapping = {}
-        for img_meta in coco_annotations['images']:
-            image_id_mapping[img_meta['id']] = img_meta['file_name']
+        for img_meta in coco_annotations["images"]:
+            image_id_mapping[img_meta["id"]] = img_meta["file_name"]
         coco_map = {fname: [] for fname in image_id_mapping.values()}
         image_category_map = {k: [] for k in coco_map.keys()}
-        for a_meta in coco_annotations['annotations']:
-            image_category_map[image_id_mapping[a_meta['image_id']]] \
-                .append(a_meta['category_id'])
-            coco_map[image_id_mapping[a_meta['image_id']]].append(a_meta)
+        for a_meta in coco_annotations["annotations"]:
+            image_category_map[image_id_mapping[a_meta["image_id"]]].append(a_meta["category_id"])
+            coco_map[image_id_mapping[a_meta["image_id"]]].append(a_meta)
         self._labels_for_image = image_category_map
         self._data = coco_map
-
diff --git a/agml/data/experimental.py b/agml/data/experimental.py
index 59617d7c..e3f26eb3 100644
--- a/agml/data/experimental.py
+++ b/agml/data/experimental.py
@@ -15,12 +15,12 @@
 """
 Experimental data utilities that are in development.
 """
+
 import functools
 
 import numpy as np
 
-
-__all__ = ['generate_keras_segmentation_dual_transform']
+__all__ = ["generate_keras_segmentation_dual_transform"]
 
 
 def generate_keras_segmentation_dual_transform(*layers):
@@ -59,6 +59,7 @@ def generate_keras_segmentation_dual_transform(*layers):
     -------
     """
     import tensorflow as tf
+
     if len(layers) == 1:
         if isinstance(layers[0], tf.keras.Sequential):
             layers = layers[0].layers
@@ -70,35 +71,30 @@ def _internal(image, annotation, seed):
             instantiated_layer = functools.partial(layer_, **build_dict)
             seed_update = {}
             if seed is not None:
-                seed_update['seed'] = seed
+                seed_update["seed"] = seed
             image = instantiated_layer(**seed_update)(image)
             annotation = instantiated_layer(**seed_update)(annotation)
             return image, annotation
+
         return _internal
 
     preprocessing_methods, use_seeds = [], []
     for layer in layers:
         config = layer.get_config()
-        if 'seed' in config:
-            config.pop('seed')
+        if "seed" in config:
+            config.pop("seed")
             use_seeds.append(True)
         else:
             use_seeds.append(False)
-        preprocessing_methods.append(
-            _single_preprocessing_layer_base(layer.__class__, config))
+        preprocessing_methods.append(_single_preprocessing_layer_base(layer.__class__, config))
 
     def _execute_preprocessing(layers_, use_seeds_):
         def _execute(image, annotation):
             for p_layer, seed_ in zip(layers_, use_seeds_):
                 seed = np.random.randint(2147483647) if seed_ else None
-                image, annotation = p_layer(image, annotation, seed = seed)
+                image, annotation = p_layer(image, annotation, seed=seed)
             return image, annotation
-        return _execute
-    return _execute_preprocessing(preprocessing_methods, use_seeds)
-
-
-
-
-
 
+        return _execute
 
+    return _execute_preprocessing(preprocessing_methods, use_seeds)
diff --git a/agml/data/exporters/__init__.py b/agml/data/exporters/__init__.py
index 3802219b..ecd05fd8 100644
--- a/agml/data/exporters/__init__.py
+++ b/agml/data/exporters/__init__.py
@@ -1 +1 @@
-from .yolo import export_yolo
\ No newline at end of file
+from .yolo import export_yolo
diff --git a/agml/data/exporters/tensorflow.py b/agml/data/exporters/tensorflow.py
index 571c5a34..a959a54d 100644
--- a/agml/data/exporters/tensorflow.py
+++ b/agml/data/exporters/tensorflow.py
@@ -24,32 +24,34 @@ class TFExporter(object):
     This class manages the methods and conversions between `AgMLDataLoader`
     parameters, managers, and methods, into TensorFlow native methods.
     """
+
     def __init__(self, task, builder):
         self._task = task
         self._builder = builder
 
     def digest_transforms(self, transforms, resizing):
         """Parses the transforms for the `AgMLDataLoader`."""
-        self._transforms = {
-            k: state for k, state in transforms.items()}
+        self._transforms = {k: state for k, state in transforms.items()}
         self._size = resizing if resizing is not None else (512, 512)
 
     def assign_state(self, state):
         """Updates the training state for the `tf.data.Dataset`."""
-        if state in [TrainState.EVAL,
-                     TrainState.EVAL_TF,
-                     TrainState.EVAL_TORCH,
-                     TrainState.FALSE]:
-            self._state = 'eval'
+        if state in [
+            TrainState.EVAL,
+            TrainState.EVAL_TF,
+            TrainState.EVAL_TORCH,
+            TrainState.FALSE,
+        ]:
+            self._state = "eval"
         else:
-            self._state = 'train'
+            self._state = "train"
 
     def _build_from_contents_by_type(self, builder):
         """Parses the provided mapping into a valid set of contents."""
-        if self._task == 'image_classification':
+        if self._task == "image_classification":
             ds = self._build_image_classification(builder)
             return ds.map(self._image_classification_load)
-        elif self._task == 'semantic_segmentation':
+        elif self._task == "semantic_segmentation":
             ds = self._build_semantic_segmentation(builder)
             return ds.map(self._semantic_segmentation_load)
         else:
@@ -58,29 +60,31 @@ def _build_from_contents_by_type(self, builder):
 
     def _apply_resizing_by_type(self, ds):
         """Applies resizing based on the task."""
-        if self._task == 'image_classification':
+        if self._task == "image_classification":
             return ds.map(self._image_classification_resize)
-        elif self._task == 'semantic_segmentation':
+        elif self._task == "semantic_segmentation":
             return ds.map(self._semantic_segmentation_resize)
         else:
             return ds.map(self._object_detection_resize)
 
-    def build(self, batch_size = None):
+    def build(self, batch_size=None):
         """Builds the `tf.data.Dataset` using the provided parameters."""
         # Construct the dataset from the contents.
         ds = self._build_from_contents_by_type(self._builder)
 
         # Apply the digested transforms and resizing.
         ds = self._apply_resizing_by_type(ds)
-        if self._state != 'eval':
+        if self._state != "eval":
             # No transforms for object detection, since it is near impossible
             # for TensorFlow's graph mode to use COCO JSON dictionaries.
-            if self._task == 'object_detection':
+            if self._task == "object_detection":
                 if len(self._transforms) != 0:
-                    log("Got transforms when exporting an `AgMLDataLoader`"
+                    log(
+                        "Got transforms when exporting an `AgMLDataLoader`"
                         "to a `tf.data.Dataset`. These transforms will not be "
                         "applied. To use transforms in TensorFlow, use the "
-                        "`as_keras_sequence()` method instead.")
+                        "`as_keras_sequence()` method instead."
+                    )
             else:
                 tfm = self._apply_transforms
                 if len(self._transforms) != 0:
@@ -97,37 +101,38 @@ def build(self, batch_size = None):
 
     @staticmethod
     def _build_image_classification(builder):
-        images, labels = builder.export_contents(
-            export_format = 'arrays')
+        images, labels = builder.export_contents(export_format="arrays")
         images, labels = tf.constant(images), tf.constant(labels)
         ds = tf.data.Dataset.from_tensor_slices((images, labels))
         return ds.shuffle(len(images))
 
     @staticmethod
     def _build_semantic_segmentation(builder):
-        images, masks = builder.export_contents(
-            export_format = 'arrays')
+        images, masks = builder.export_contents(export_format="arrays")
         images, masks = tf.constant(images), tf.constant(masks)
         ds = tf.data.Dataset.from_tensor_slices((images, masks))
         return ds.shuffle(len(images))
 
     @staticmethod
     def _build_object_detection(builder):
-        images, annotations = builder.export_contents(
-            export_format = 'arrays')
+        images, annotations = builder.export_contents(export_format="arrays")
         images = tf.constant(images)
-        processed_annotations = [
-            DataObject._parse_coco(a) for a in annotations]
-        features = {'bbox': [], 'category_id': [], 'area': [],
-                    'image_id': [], 'iscrowd': [], 'segmentation': []}
+        processed_annotations = [DataObject._parse_coco(a) for a in annotations]
+        features = {
+            "bbox": [],
+            "category_id": [],
+            "area": [],
+            "image_id": [],
+            "iscrowd": [],
+            "segmentation": [],
+        }
         for a_set in processed_annotations:
             for feature in features.keys():
-                features[feature].append(a_set[feature]) # noqa
+                features[feature].append(a_set[feature])  # noqa
         for feature in features.keys():
             features[feature] = tf.ragged.constant(features[feature])
         feature_ds = tf.data.Dataset.from_tensor_slices(features)
-        ds = tf.data.Dataset.zip((
-            tf.data.Dataset.from_tensor_slices(images), feature_ds))
+        ds = tf.data.Dataset.zip((tf.data.Dataset.from_tensor_slices(images), feature_ds))
         return ds.shuffle(len(images))
 
     # The following methods are used for loading images and
@@ -136,41 +141,37 @@ def _build_object_detection(builder):
     @staticmethod
     @tf.function
     def _image_classification_load(image, label):
-        image = tf.cast(tf.image.decode_jpeg(
-            tf.io.read_file(image)), tf.float32) / 255.
+        image = tf.cast(tf.image.decode_jpeg(tf.io.read_file(image)), tf.float32) / 255.0
         return image, tf.convert_to_tensor(label)
 
     @staticmethod
     @tf.function
     def _semantic_segmentation_load(image, mask):
-        image = tf.cast(tf.image.decode_jpeg(
-            tf.io.read_file(image)), tf.float32) / 255.
+        image = tf.cast(tf.image.decode_jpeg(tf.io.read_file(image)), tf.float32) / 255.0
         mask = tf.image.decode_jpeg(tf.io.read_file(mask))
         return image, mask
 
     @staticmethod
     @tf.function
     def _object_detection_load(image, coco):
-        image = tf.cast(tf.image.decode_jpeg(
-            tf.io.read_file(image)), tf.float32) / 255.
+        image = tf.cast(tf.image.decode_jpeg(tf.io.read_file(image)), tf.float32) / 255.0
         ret_coco = coco.copy()
         for key in coco.keys():
-            try: ret_coco[key] = coco[key].to_tensor()
-            except: pass
+            try:
+                ret_coco[key] = coco[key].to_tensor()
+            except:
+                pass
         return image, ret_coco
 
     # The following methods apply resizing to the data.
 
     def _image_classification_resize(self, image, label):
-        image = (tf.image.resize(
-            image, self._size, method = 'nearest'), tf.float32)
+        image = (tf.image.resize(image, self._size, method="nearest"), tf.float32)
         return image, label
 
     def _semantic_segmentation_resize(self, image, mask):
-        image = tf.cast(tf.image.resize(
-            image, self._size, method = 'nearest'), tf.float32)
-        mask = tf.cast(tf.image.resize(
-            mask, self._size, method = 'nearest'), tf.float32)
+        image = tf.cast(tf.image.resize(image, self._size, method="nearest"), tf.float32)
+        mask = tf.cast(tf.image.resize(mask, self._size, method="nearest"), tf.float32)
         return image, mask
 
     def _object_detection_resize(self, image, coco):
@@ -179,19 +180,28 @@ def _resize_image_and_bboxes(image, coco_boxes):
             nonlocal size
             y_scale, x_scale = image.shape[0:2]
             stack_boxes = tf.stack(
-                [coco_boxes[:, 0] / x_scale,
-                 coco_boxes[:, 1] / y_scale,
-                 coco_boxes[:, 2] / x_scale,
-                 coco_boxes[:, 3] / y_scale], axis = -1)
-            image = tf.cast(tf.image.resize(
-                image, size), tf.float32)
+                [
+                    coco_boxes[:, 0] / x_scale,
+                    coco_boxes[:, 1] / y_scale,
+                    coco_boxes[:, 2] / x_scale,
+                    coco_boxes[:, 3] / y_scale,
+                ],
+                axis=-1,
+            )
+            image = tf.cast(tf.image.resize(image, size), tf.float32)
             y_new, x_new = image.shape[0:2]
-            new_stack = tf.cast(tf.stack(
-                [stack_boxes[:, 0] * x_new,
-                 stack_boxes[:, 1] * y_new,
-                 stack_boxes[:, 2] * x_new,
-                 stack_boxes[:, 3] * y_new], axis = -1
-            ), tf.int32)
+            new_stack = tf.cast(
+                tf.stack(
+                    [
+                        stack_boxes[:, 0] * x_new,
+                        stack_boxes[:, 1] * y_new,
+                        stack_boxes[:, 2] * x_new,
+                        stack_boxes[:, 3] * y_new,
+                    ],
+                    axis=-1,
+                ),
+                tf.int32,
+            )
             areas = new_stack[:, 2] * new_stack[:, 3]
             return image, new_stack, areas
 
@@ -201,10 +211,11 @@ def _resize_image_and_bboxes(image, coco_boxes):
         size = self._size
         image, ret_coco_boxes, ret_areas = tf.py_function(
             _resize_image_and_bboxes,
-            [image, coco['bbox']],
-            [tf.float32, tf.int32, tf.int32])
-        coco['bbox'] = ret_coco_boxes
-        coco['area'] = ret_areas
+            [image, coco["bbox"]],
+            [tf.float32, tf.int32, tf.int32],
+        )
+        coco["bbox"] = ret_coco_boxes
+        coco["area"] = ret_areas
         return image, coco
 
     # The following method manages the application of transforms.
@@ -215,10 +226,10 @@ def _py_apply(img, ann):
             nonlocal transforms
             img, ann = img.numpy(), ann.numpy()
             for key, state in transforms.items():
-                if key == 'transform':
+                if key == "transform":
                     for t in state:
                         img = t(img)
-                elif key == 'target_transform':
+                elif key == "target_transform":
                     for t in state:
                         ann = t(ann)
                 else:
@@ -230,17 +241,5 @@ def _py_apply(img, ann):
         # The actual transforming can't take place in graph mode
         # (in most cases), so we dispatch and reassign.
         transforms = self._transforms
-        image, annotation = tf.py_function(
-            _py_apply,
-            [image, annotation],
-            [tf.float32, tf.int32])
+        image, annotation = tf.py_function(_py_apply, [image, annotation], [tf.float32, tf.int32])
         return image, annotation
-
-
-
-
-
-
-
-
-
diff --git a/agml/data/exporters/yolo.py b/agml/data/exporters/yolo.py
index 894212a9..22f47069 100644
--- a/agml/data/exporters/yolo.py
+++ b/agml/data/exporters/yolo.py
@@ -1,7 +1,8 @@
 import os
-import yaml
 import shutil
 
+import yaml
+
 import agml
 from agml.utils.general import flatten
 from agml.utils.logging import log
@@ -11,14 +12,20 @@ def convert_annotations_to_yolo_list(annotation_dict, image_shape, annotation_re
     yolo_list = []
     height, width = image_shape
     for annotation in annotation_dict:
-        x, y, w, h = annotation['bbox']
+        x, y, w, h = annotation["bbox"]
         x_center = x + w / 2
         y_center = y + h / 2
 
         # scale XYWH to [0, 1]
-        yolo_list.append([annotation_remapper[annotation['category_id']],
-                          x_center / width, y_center / height,
-                          w / width, h / width])
+        yolo_list.append(
+            [
+                annotation_remapper[annotation["category_id"]],
+                x_center / width,
+                y_center / height,
+                w / width,
+                h / width,
+            ]
+        )
     return yolo_list
 
 
@@ -59,33 +66,31 @@ def export_yolo(dataset, yolo_path=None):
         loader = dataset
 
     if yolo_path is None:
-        yolo_path = os.path.join(os.getcwd(), f'{loader.name}_yolo_export')
-    if not os.path.exists(os.path.join(yolo_path, 'data')):
+        yolo_path = os.path.join(os.getcwd(), f"{loader.name}_yolo_export")
+    if not os.path.exists(os.path.join(yolo_path, "data")):
         log("YOLO Export Tool did not receive a valid YOLO path. Creating a new directory for the export.")
 
-    yolo_data_path = os.path.join(yolo_path, 'datasets', loader.name)
-    output_image_dir = os.path.join(yolo_data_path, 'images')
-    output_annotation_dir = os.path.join(yolo_data_path, 'labels')
+    yolo_data_path = os.path.join(yolo_path, "datasets", loader.name)
+    output_image_dir = os.path.join(yolo_data_path, "images")
+    output_annotation_dir = os.path.join(yolo_data_path, "labels")
     os.makedirs(output_image_dir, exist_ok=True)
     os.makedirs(output_annotation_dir, exist_ok=True)
 
     # create the dataset YAML
-    yaml_dump = {
-        'path': yolo_data_path,
-        'names': loader.num_to_class
-    }
+    yaml_dump = {"path": yolo_data_path, "names": loader.num_to_class}
 
     # AgML indexes object detection datasets from 1 -> N, so reindex from 0 -> N-1
-    class_mapper = {i: i - 1 for i in yaml_dump['names']}
-    yaml_dump['names'] = {i - 1: name for i, name in yaml_dump['names'].items()}
+    class_mapper = {i: i - 1 for i in yaml_dump["names"]}
+    yaml_dump["names"] = {i - 1: name for i, name in yaml_dump["names"].items()}
 
     # get the height/width for all the images for normalization purposes
     if loader.IS_MULTI_DATASET:
-        image_info = flatten([sub_loader._builder._default_coco_annotations['images']
-                              for sub_loader in loader._loaders])  # noqa
+        image_info = flatten(
+            [sub_loader._builder._default_coco_annotations["images"] for sub_loader in loader._loaders]
+        )  # noqa
     else:
-        image_info = loader._builder._default_coco_annotations['images']
-    image_info = {image['file_name']: (image['height'], image['width']) for image in image_info}
+        image_info = loader._builder._default_coco_annotations["images"]
+    image_info = {image["file_name"]: (image["height"], image["width"]) for image in image_info}
 
     # compatibility for content format for multi-dataset loaders
     if not loader.IS_MULTI_DATASET:
@@ -96,8 +101,8 @@ def export_yolo(dataset, yolo_path=None):
     # check for data splits and get a list of images in each split
     all_split_images = {}
     if loader._is_split_generated():
-        for split_name in ['train', 'val', 'test']:
-            split_content = getattr(loader, f'_{split_name}_content')
+        for split_name in ["train", "val", "test"]:
+            split_content = getattr(loader, f"_{split_name}_content")
             if not loader.IS_MULTI_DATASET:
                 split_content = {loader.name: split_content}
 
@@ -105,23 +110,30 @@ def export_yolo(dataset, yolo_path=None):
             if all(i is None for i in split_content.values()):
                 continue
 
-            split_images = flatten([[f'{curr_name}_{os.path.basename(image)}' for image in curr_split]
-                                    for curr_name, curr_split in split_content.items()])
+            split_images = flatten(
+                [
+                    [f"{curr_name}_{os.path.basename(image)}" for image in curr_split]
+                    for curr_name, curr_split in split_content.items()
+                ]
+            )
             all_split_images[split_name] = split_images
     else:
         # if no split generated, put all in `train`
-        all_split_images['train'] = flatten([[f'{loader.name}_{os.path.basename(image)}'
-                                                for image in curr_split]
-                                                for curr_split in loader_contents.values()])
+        all_split_images["train"] = flatten(
+            [
+                [f"{loader.name}_{os.path.basename(image)}" for image in curr_split]
+                for curr_split in loader_contents.values()
+            ]
+        )
 
     # write the text files containing the split contents
     for split_name, split_images in all_split_images.items():
         split_images = [os.path.join(output_image_dir, image) for image in split_images]
-        with open(os.path.join(yolo_data_path, f'{split_name}.txt'), 'w') as f:
+        with open(os.path.join(yolo_data_path, f"{split_name}.txt"), "w") as f:
             f.write("\n".join(split_images))
 
         # update the YAML file with the corresponding locs of train/val/test
-        yaml_dump[split_name] = f'{split_name}.txt'
+        yaml_dump[split_name] = f"{split_name}.txt"
 
     for loader_name, loader_content in loader_contents.items():
         for image, annotation_set in loader_content.items():
@@ -133,16 +145,16 @@ def export_yolo(dataset, yolo_path=None):
 
             # the name of the new image is {dataset_name}_{old_name}.{ext}
             image_name = f"{loader_name}_{os.path.basename(image)}"
-            txt_name = os.path.splitext(image_name)[0] + '.txt'
+            txt_name = os.path.splitext(image_name)[0] + ".txt"
 
             # save the image and the text file
             shutil.copy(image, os.path.join(output_image_dir, image_name))
-            with open(os.path.join(output_annotation_dir, txt_name), 'w') as f:
+            with open(os.path.join(output_annotation_dir, txt_name), "w") as f:
                 f.write(text_content)
 
     # write the dataset.yaml file
-    os.makedirs(os.path.join(yolo_path, 'data'), exist_ok=True)
-    with open(os.path.join(yolo_path, 'data', 'dataset.yaml'), 'w') as f:
+    os.makedirs(os.path.join(yolo_path, "data"), exist_ok=True)
+    with open(os.path.join(yolo_path, "data", "dataset.yaml"), "w") as f:
         yaml.safe_dump(yaml_dump, f)
 
     # log information about the dataset location
@@ -151,10 +163,10 @@ def export_yolo(dataset, yolo_path=None):
 
     You can find the dataset at the following location: {0}
     The dataset metadata is stored at {1}
-    """.format(yolo_data_path, os.path.join(yolo_path, 'data', 'dataset.yaml'))
+    """.format(yolo_data_path, os.path.join(yolo_path, "data", "dataset.yaml"))
     log(information)
 
-    return {'dataset_path': yolo_data_path, 'metadata_path': os.path.join(yolo_path, 'data', 'dataset.yaml')}
-
-
-
+    return {
+        "dataset_path": yolo_data_path,
+        "metadata_path": os.path.join(yolo_path, "data", "dataset.yaml"),
+    }
diff --git a/agml/data/extensions/cvat.py b/agml/data/extensions/cvat.py
index 61de33b1..ac4adf8a 100644
--- a/agml/data/extensions/cvat.py
+++ b/agml/data/extensions/cvat.py
@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import os
 import shutil
-import json
 
 
 def restructure_cvat_annotations(image_dir, cvat_dir, dataset_name, output_dir=None):
@@ -42,11 +42,12 @@ def restructure_cvat_annotations(image_dir, cvat_dir, dataset_name, output_dir=N
     # Determine the dataset path
     if output_dir is None:
         import agml.backend  # Ensure that agml is imported
+
         dataset_path = os.path.join(agml.backend.data_save_path(), dataset_name)
     else:
         dataset_path = os.path.join(output_dir, dataset_name)
 
-    images_output_dir = os.path.join(dataset_path, 'images')
+    images_output_dir = os.path.join(dataset_path, "images")
     os.makedirs(images_output_dir, exist_ok=True)
 
     # Copy images to the new dataset directory
@@ -56,8 +57,8 @@ def restructure_cvat_annotations(image_dir, cvat_dir, dataset_name, output_dir=N
         shutil.copy2(src_image_path, dst_image_path)
 
     # Load the CVAT annotations
-    cvat_annotations_path = os.path.join(cvat_dir, 'instances_default.json')
-    with open(cvat_annotations_path, 'r') as f:
+    cvat_annotations_path = os.path.join(cvat_dir, "instances_default.json")
+    with open(cvat_annotations_path, "r") as f:
         coco = json.load(f)
 
     # Build a mapping from base image names to actual filenames (with extensions)
@@ -68,20 +69,20 @@ def restructure_cvat_annotations(image_dir, cvat_dir, dataset_name, output_dir=N
         base_name_to_file_name[base_name] = file_name
 
     # Update the 'file_name' field in each image entry to match the actual filenames
-    for image in coco.get('images', []):
-        original_file_name = image['file_name']
+    for image in coco.get("images", []):
+        original_file_name = image["file_name"]
         base_name, _ = os.path.splitext(original_file_name)
         actual_file_name = base_name_to_file_name.get(base_name)
 
         if actual_file_name:
-            image['file_name'] = actual_file_name
+            image["file_name"] = actual_file_name
         else:
             print(f"Warning: No matching image file found for '{original_file_name}'.")
             # Optionally, handle this case as needed (e.g., remove the image from the list)
 
     # Save the updated annotations to 'annotations.json' in the new dataset directory
-    annotations_output_path = os.path.join(dataset_path, 'annotations.json')
-    with open(annotations_output_path, 'w') as f:
+    annotations_output_path = os.path.join(dataset_path, "annotations.json")
+    with open(annotations_output_path, "w") as f:
         json.dump(coco, f)
 
-    print(f"Dataset '{dataset_name}' has been created successfully at '{dataset_path}'.")
\ No newline at end of file
+    print(f"Dataset '{dataset_name}' has been created successfully at '{dataset_path}'.")
diff --git a/agml/data/image_loader.py b/agml/data/image_loader.py
index 8afda74b..4e43f659 100644
--- a/agml/data/image_loader.py
+++ b/agml/data/image_loader.py
@@ -17,9 +17,9 @@
 import cv2
 import numpy as np
 
-from agml.framework import AgMLSerializable
 from agml.data.loader import AgMLDataLoader
 from agml.data.public import public_data_sources
+from agml.framework import AgMLSerializable
 from agml.utils.io import nested_file_list
 from agml.utils.random import inject_random_state
 
@@ -40,10 +40,10 @@ class ImageLoader(AgMLSerializable):
     image_size : tuple, optional
         The size to resize the images to. If `None`, the images will not be resized.
     """
-    serializable = frozenset(
-        ('accessor_list', 'image_size', 'grayscale', 'return_paths', 'transforms'))
 
-    def __init__(self, location, image_size = None, **kwargs):
+    serializable = frozenset(("accessor_list", "image_size", "grayscale", "return_paths", "transforms"))
+
+    def __init__(self, location, image_size=None, **kwargs):
         # Parse the input `location`: this can be either a directory of images,
         # a directory tree with nested image folders, or an AgML dataset.
         self._setup_loader(location, **kwargs)
@@ -53,7 +53,7 @@ def __init__(self, location, image_size = None, **kwargs):
 
         # Save class variables.
         self._image_size = None
-        self.image_size = image_size # checks for validity.
+        self.image_size = image_size  # checks for validity.
         self._grayscale = False
         self._return_paths = False
         self._transforms = []
@@ -97,7 +97,7 @@ def image_size(self, value):
                 value = (value, value)
             if len(value) != 2:
                 raise ValueError("Cannot use `image_size` with more than two dimensions.")
-            value = (value[0], value[1]) # convert to tuples for cv2.resize
+            value = (value[0], value[1])  # convert to tuples for cv2.resize
         self._image_size = value
 
     @property
@@ -130,15 +130,15 @@ def _setup_loader(self, location, **kwargs):
             if isinstance(self._root_path, list):
                 image_files = []
                 for root_path in self._root_path:
-                    image_files.extend(nested_file_list(root_path, ext='image'))
+                    image_files.extend(nested_file_list(root_path, ext="image"))
                 self._image_files = sorted(image_files)
             else:
-                self._image_files = sorted(nested_file_list(self._root_path, ext='image'))
+                self._image_files = sorted(nested_file_list(self._root_path, ext="image"))
         elif location in public_data_sources():
             # This is a quick way to run all of the checks regarding the location
             # of the dataset, and download it if it isn't already downloaded.
             self._root_path = AgMLDataLoader(location, **kwargs).dataset_root
-            self._image_files = sorted(nested_file_list(self._root_path, ext='image'))
+            self._image_files = sorted(nested_file_list(self._root_path, ext="image"))
 
         # If the folder itself is a directory of images, then we can just use
         # the directory as the root path.
@@ -146,11 +146,11 @@ def _setup_loader(self, location, **kwargs):
             self._root_path = os.path.abspath(location)
 
             # Get all of the image files.
-            self._image_files = sorted(nested_file_list(self._root_path, ext='image'))
+            self._image_files = sorted(nested_file_list(self._root_path, ext="image"))
 
         # Otherwise, the given path is invalid.
         else:
-            raise ValueError(f'Invalid path for `ImageLoader`: {location}')
+            raise ValueError(f"Invalid path for `ImageLoader`: {location}")
 
     def transform(self, transform):
         """Adds a transform to the loader.
@@ -161,4 +161,3 @@ def transform(self, transform):
             A function which takes in an image and returns a modified image.
         """
         self._transforms.append(transform)
-
diff --git a/agml/data/loader.py b/agml/data/loader.py
index 7406e939..bbf6f8d6 100644
--- a/agml/data/loader.py
+++ b/agml/data/loader.py
@@ -12,36 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
-import json
 import copy
-import glob
 import fnmatch
-from typing import Union
+import glob
+import json
+import os
 from collections.abc import Sequence
-from decimal import getcontext, Decimal
+from decimal import Decimal, getcontext
+from typing import Union
 
 import numpy as np
 
-from agml.framework import AgMLSerializable
-from agml.data.manager import DataManager
+from agml.backend.config import SUPER_BASE_DIR, data_save_path, synthetic_data_save_path
+from agml.backend.experimental import AgMLExperimentalFeatureWrapper
+from agml.backend.tftorch import (
+    StrictBackendError,
+    _add_dataset_to_mro,  # noqa
+    get_backend,
+    set_backend,
+    user_changed_backend,
+)
 from agml.data.builder import DataBuilder
-from agml.data.metadata import DatasetMetadata, make_metadata
 from agml.data.exporters.yolo import export_yolo
-from agml.utils.logging import log
-from agml.utils.io import get_file_list, get_dir_list
+from agml.data.manager import DataManager
+from agml.data.metadata import DatasetMetadata, make_metadata
+from agml.framework import AgMLSerializable
 from agml.utils.data import load_public_sources
 from agml.utils.general import NoArgument, resolve_list_value
+from agml.utils.io import get_dir_list, get_file_list
+from agml.utils.logging import log
 from agml.utils.random import inject_random_state
-from agml.backend.config import (
-    data_save_path, synthetic_data_save_path, SUPER_BASE_DIR
-)
-from agml.backend.experimental import AgMLExperimentalFeatureWrapper
-from agml.backend.tftorch import (
-    get_backend, set_backend,
-    user_changed_backend, StrictBackendError,
-    _add_dataset_to_mro, # noqa
-)
 from agml.viz.general import show_sample
 
 
@@ -53,12 +53,13 @@ def __instancecheck__(self, instance):
         if isinstance(instance, self.__class__):
             return True
         from agml.data.multi_loader import AgMLMultiDatasetLoader
+
         if isinstance(instance, AgMLMultiDatasetLoader):
             return True
         return False
 
 
-class AgMLDataLoader(AgMLSerializable, metaclass = AgMLDataLoaderMeta):
+class AgMLDataLoader(AgMLSerializable, metaclass=AgMLDataLoaderMeta):
     """Loads and provides a processing interface for a dataset.
 
     The `AgMLDataLoader` is the main interface to AgML's public dataset
@@ -104,66 +105,85 @@ class AgMLDataLoader(AgMLSerializable, metaclass = AgMLDataLoaderMeta):
     -----
     See the methods for examples on how to use an `AgMLDataLoader` effectively.
     """
+
     IS_MULTI_DATASET: bool = False
 
-    serializable = frozenset((
-        'info', 'builder', 'manager', 'train_data', 'train_content', 'val_data',
-        'val_content', 'test_data', 'test_content', 'is_split', 'meta_properties'))
+    serializable = frozenset(
+        (
+            "info",
+            "builder",
+            "manager",
+            "train_data",
+            "train_content",
+            "val_data",
+            "val_content",
+            "test_data",
+            "test_content",
+            "is_split",
+            "meta_properties",
+        )
+    )
 
     def __new__(cls, dataset, **kwargs):
         # If a single dataset is passed, then we use the base `AgMLDataLoader`.
         # However, if an iterable of datasets is passed, then we need to
         # dispatch to the subclass `AgMLMultiDatasetLoader` for them.
         if isinstance(dataset, (str, DatasetMetadata)):
-            if '*' in dataset:  # enables wildcard search for datasets
+            if "*" in dataset:  # enables wildcard search for datasets
                 valid_datasets = fnmatch.filter(load_public_sources().keys(), dataset)
                 if len(valid_datasets) == 0:
-                    raise ValueError(
-                        f"Wildcard search for dataset '{dataset}' yielded no results.")
+                    raise ValueError(f"Wildcard search for dataset '{dataset}' yielded no results.")
                 if len(valid_datasets) == 1:
-                    log(f"Wildcard search for dataset '{dataset}' yielded only "
-                        f"one result. Returning a regular, single-element data loader.")
+                    log(
+                        f"Wildcard search for dataset '{dataset}' yielded only "
+                        f"one result. Returning a regular, single-element data loader."
+                    )
                     return super(AgMLDataLoader, cls).__new__(cls)
                 from agml.data.multi_loader import AgMLMultiDatasetLoader
+
                 return AgMLMultiDatasetLoader(valid_datasets, **kwargs)
             return super(AgMLDataLoader, cls).__new__(cls)
         elif isinstance(dataset, Sequence):
             if len(dataset) == 1:
-                log("Received a sequence with only one element when "
+                log(
+                    "Received a sequence with only one element when "
                     "instantiating an `AgMLDataLoader`. Returning "
-                    "a regular, single-element data loader.")
+                    "a regular, single-element data loader."
+                )
                 return super(AgMLDataLoader, cls).__new__(cls)
             from agml.data.multi_loader import AgMLMultiDatasetLoader
+
             return AgMLMultiDatasetLoader(dataset, **kwargs)
         raise TypeError(
             f"Expected either a single dataset name (or metadata), or"
             f"a list of dataset names/metadata when instantiating an "
-            f"`AgMLDataLoader`. Got {dataset} of type {type(dataset)}.")
+            f"`AgMLDataLoader`. Got {dataset} of type {type(dataset)}."
+        )
 
     def __getnewargs__(self):
-        return self._info.name,
+        return (self._info.name,)
 
     def __init__(self, dataset, **kwargs):
         """Instantiates an `AgMLDataLoader` with the dataset."""
         # Set up the dataset and its associated metadata.
-        self._info = make_metadata(dataset, kwargs.get('meta', None))
+        self._info = make_metadata(dataset, kwargs.get("meta", None))
 
         # The data for the class is constructed in two stages. First, the
         # internal contents are constructed using a `DataBuilder`, which
         # finds and wraps the local data in a proper format.
         self._builder = DataBuilder(
-            info = self._info,
-            dataset_path = kwargs.get('dataset_path', None),
-            overwrite = kwargs.get('overwrite', False)
+            info=self._info,
+            dataset_path=kwargs.get("dataset_path", None),
+            overwrite=kwargs.get("overwrite", False),
         )
 
         # These contents are then passed to a `DataManager`, which conducts
         # the actual loading and processing of the data when called.
         self._manager = DataManager(
-            builder = self._builder,
-            task = self._info.tasks.ml,
-            name = self._info.name,
-            root = self._builder.dataset_root
+            builder=self._builder,
+            task=self._info.tasks.ml,
+            name=self._info.name,
+            root=self._builder.dataset_root,
         )
 
         # If the dataset is split, then the `AgMLDataLoader`s with the
@@ -180,15 +200,16 @@ def __init__(self, dataset, **kwargs):
         # `classes`, since these can be modified depending on the state of
         # the loader, whilst the `info` parameter attributes cannot.
         self._meta_properties = {
-            'num_images': self._info.num_images,
-            'classes': self._info.classes,
-            'num_classes': self._info.num_classes,
-            'num_to_class': self._info.num_to_class,
-            'class_to_num': self._info.class_to_num,
-            'data_distributions': {self.name: self._info.num_images}}
+            "num_images": self._info.num_images,
+            "classes": self._info.classes,
+            "num_classes": self._info.num_classes,
+            "num_to_class": self._info.num_to_class,
+            "class_to_num": self._info.class_to_num,
+            "data_distributions": {self.name: self._info.num_images},
+        }
 
     @classmethod
-    def custom(cls, name, dataset_path = None, classes = None, **kwargs):
+    def custom(cls, name, dataset_path=None, classes=None, **kwargs):
         """Creates an `AgMLDataLoader` with a set of custom data.
 
         If you have a custom dataset that you want to use in an `AgMLDataLoader`,
@@ -249,9 +270,11 @@ def custom(cls, name, dataset_path = None, classes = None, **kwargs):
         """
         # Check the name and ensure that no dataset with that name exists.
         if name in load_public_sources().keys() or not isinstance(name, str):
-            raise ValueError(f"Invalid name '{name}', the name should be "
-                             f"a string that is not an existing dataset in "
-                             f"the AgML public data source repository.")
+            raise ValueError(
+                f"Invalid name '{name}', the name should be "
+                f"a string that is not an existing dataset in "
+                f"the AgML public data source repository."
+            )
 
         # Check if the `name` is itself the path to the dataset.
         if os.path.exists(name):
@@ -265,57 +288,62 @@ def custom(cls, name, dataset_path = None, classes = None, **kwargs):
                 raise NotADirectoryError(
                     f"Existing directory '{dataset_path}' for dataset of name "
                     f"{name} not found, pass a custom path if you want to use "
-                    f"a custom dataset path for the dataset.")
+                    f"a custom dataset path for the dataset."
+                )
         else:
             dataset_path = os.path.abspath(os.path.expanduser(dataset_path))
             if not os.path.exists(dataset_path):
                 if not os.path.exists(dataset_path):
                     raise NotADirectoryError(
                         f"Could not find a directory for dataset '{name}' at the "
-                        f"provided dataset path: {dataset_path}.")
+                        f"provided dataset path: {dataset_path}."
+                    )
             if not dataset_path.endswith(name):
                 dataset_path = os.path.join(dataset_path, name)
                 if not os.path.exists(dataset_path):
                     raise NotADirectoryError(
                         f"Could not find a directory for dataset '{name}' at the "
-                        f"provided dataset path: {dataset_path}.")
+                        f"provided dataset path: {dataset_path}."
+                    )
 
         # Infer the task based on the provided dataset path.
-        if os.path.exists(os.path.join(dataset_path, 'annotations.json')):
-            task = 'object_detection'
-        elif os.path.exists(os.path.join(dataset_path, 'images')) and \
-                os.path.exists(os.path.join(dataset_path, 'annotations')):
-            task = 'semantic_segmentation'
-        elif len(get_file_list(dataset_path)) == 0 and \
-                len(get_dir_list(dataset_path)) != 0:
-            task = 'image_classification'
+        if os.path.exists(os.path.join(dataset_path, "annotations.json")):
+            task = "object_detection"
+        elif os.path.exists(os.path.join(dataset_path, "images")) and os.path.exists(
+            os.path.join(dataset_path, "annotations")
+        ):
+            task = "semantic_segmentation"
+        elif len(get_file_list(dataset_path)) == 0 and len(get_dir_list(dataset_path)) != 0:
+            task = "image_classification"
         else:
             raise TypeError("Unrecognized dataset annotation format.")
 
         # Check if there is a metadata file.
-        kwargs['classes'] = classes
-        if os.path.exists(os.path.join(dataset_path, '.meta.json')):
-            with open(os.path.join(dataset_path, '.meta.json'), 'r') as f:
+        kwargs["classes"] = classes
+        if os.path.exists(os.path.join(dataset_path, ".meta.json")):
+            with open(os.path.join(dataset_path, ".meta.json"), "r") as f:
                 kwargs.update(json.load(f))
 
         # Infer the classes for image classification/object detection.
-        classes = kwargs.pop('classes')
+        classes = kwargs.pop("classes")
         if classes is None:
-            if task == 'semantic_segmentation':
-                raise ValueError(
-                    "Classes are required for a semantic segmentation task.")
-            elif task == 'image_classification':
+            if task == "semantic_segmentation":
+                raise ValueError("Classes are required for a semantic segmentation task.")
+            elif task == "image_classification":
                 classes = get_dir_list(dataset_path)
             else:  # object detection
-                with open(os.path.join(dataset_path, 'annotations.json'), 'r') as f:
-                    classes = [c['name'] for c in json.load(f)['categories']]
+                with open(os.path.join(dataset_path, "annotations.json"), "r") as f:
+                    classes = [c["name"] for c in json.load(f)["categories"]]
 
         # Construct and return the `AgMLDataLoader`.
-        return cls(name, dataset_path = dataset_path,
-                   meta = {'task': task, 'classes': classes, **kwargs})
+        return cls(
+            name,
+            dataset_path=dataset_path,
+            meta={"task": task, "classes": classes, **kwargs},
+        )
 
     @classmethod
-    def helios(cls, name, dataset_path = None):
+    def helios(cls, name, dataset_path=None):
         """Creates an `AgMLDataLoader` from a Helios-generated dataset.
         Given the path to a Helios-generated (and converted) dataset, this method
         will generate an `AgMLDataLoader` which is constructed using similar
@@ -332,72 +360,75 @@ def helios(cls, name, dataset_path = None):
                 dataset_path = [dataset_path] * len(name)
             else:
                 if not len(dataset_path) == len(name):
-                    raise ValueError("The number of dataset paths must be "
-                                     "the same as the number of dataset names.")
-            datasets = [cls.helios(n, dataset_path = dp)
-                        for n, dp in zip(name, dataset_path)]
+                    raise ValueError("The number of dataset paths must be " "the same as the number of dataset names.")
+            datasets = [cls.helios(n, dataset_path=dp) for n, dp in zip(name, dataset_path)]
             return cls.merge(*datasets)
 
         # Instantiate from a wildcard pattern.
-        if isinstance(name, str) and '*' in name:
+        if isinstance(name, str) and "*" in name:
             if dataset_path is None:
                 dataset_path = os.path.abspath(synthetic_data_save_path())
             elif not os.path.exists(dataset_path):
                 raise NotADirectoryError(
                     f"Existing directory '{dataset_path}' for dataset of name "
                     f"{name} not found, pass a custom path if you want to use "
-                    f"a custom dataset path for the dataset.")
+                    f"a custom dataset path for the dataset."
+                )
 
             # Get the list of datasets.
             possible_datasets = glob.glob(os.path.join(dataset_path, name))
             if len(possible_datasets) == 0:
                 raise ValueError(f"No datasets found for pattern: {name}.")
-            datasets = [cls.helios(os.path.basename(p), dataset_path = dataset_path)
-                        for p in sorted(possible_datasets)]
+            datasets = [cls.helios(os.path.basename(p), dataset_path=dataset_path) for p in sorted(possible_datasets)]
             return cls.merge(*datasets)
 
         # Locate the path to the dataset, using synthetic semantics.
         if dataset_path is None:
-            dataset_path = os.path.abspath(
-                os.path.join(synthetic_data_save_path(), name))
+            dataset_path = os.path.abspath(os.path.join(synthetic_data_save_path(), name))
             if not os.path.exists(dataset_path):
                 raise NotADirectoryError(
                     f"Existing directory '{dataset_path}' for dataset of name "
                     f"{name} not found, pass a custom path if you want to use "
-                    f"a custom dataset path for the dataset.")
+                    f"a custom dataset path for the dataset."
+                )
         else:
             dataset_path = os.path.abspath(os.path.expanduser(dataset_path))
             if not os.path.exists(dataset_path):
                 if not os.path.exists(dataset_path):
                     raise NotADirectoryError(
                         f"Could not find a directory for Helios dataset '{name}' "
-                        f"at the provided dataset path: {dataset_path}.")
+                        f"at the provided dataset path: {dataset_path}."
+                    )
 
             # just in case there is a locally defined folder with the same name
             # as a dataset in the `~/.agml/synthetic` directory, warn in advance:
             if os.path.exists(os.path.join(os.path.abspath(synthetic_data_save_path()), name)):
-                log(f"Found a dataset folder '{name}' in the synthetic data "
-                    f"directory, which may conflict with the Helios dataset.")
+                log(
+                    f"Found a dataset folder '{name}' in the synthetic data "
+                    f"directory, which may conflict with the Helios dataset."
+                )
             if not dataset_path.endswith(name):
                 dataset_path = os.path.join(dataset_path, name)
                 if not os.path.exists(dataset_path):
                     raise NotADirectoryError(
                         f"Could not find a directory for Helios dataset '{name}' "
-                        f"at the provided dataset path: {dataset_path}.")
+                        f"at the provided dataset path: {dataset_path}."
+                    )
 
         # Load the information file.
-        info_file = os.path.join(dataset_path, '.metadata', 'agml_info.json')
+        info_file = os.path.join(dataset_path, ".metadata", "agml_info.json")
         if not os.path.exists(info_file):
-            raise FileNotFoundError(f"The information file at '{info_file}' for the "
-                                    f"Helios dataset {name} could not be found.")
-        with open(info_file, 'r') as f:
+            raise FileNotFoundError(
+                f"The information file at '{info_file}' for the " f"Helios dataset {name} could not be found."
+            )
+        with open(info_file, "r") as f:
             meta = json.load(f)
 
         # Construct the loader.
         return cls.custom(name, dataset_path, **meta)
 
     @staticmethod
-    def merge(*loaders, classes = None):
+    def merge(*loaders, classes=None):
         """Merges a set of `AgMLDataLoader`s into a single loader.
 
         Given a set of input `AgMLDataLoader`s, this method will return a single
@@ -431,16 +462,15 @@ def merge(*loaders, classes = None):
         """
         # Validate the input loaders.
         from agml.data.multi_loader import AgMLMultiDatasetLoader
+
         if len(loaders) == 1:
             raise ValueError("There should be at least two inputs to the `merge` method.")
         for loader in loaders:
             if isinstance(loader, AgMLMultiDatasetLoader):
-                raise TypeError("Cannot merge datasets which already hold a "
-                                "collection of multiple datasets.")
+                raise TypeError("Cannot merge datasets which already hold a " "collection of multiple datasets.")
 
         # Instantiate the `AgMLMultiDatasetLoader`.
-        return AgMLMultiDatasetLoader._instantiate_from_collection(
-            *loaders, classes = classes)
+        return AgMLMultiDatasetLoader._instantiate_from_collection(*loaders, classes=classes)
 
     def __add__(self, other):
         if not isinstance(other, AgMLDataLoader):
@@ -457,13 +487,11 @@ def __getitem__(self, indexes: Union[list, int, slice]):
         if isinstance(indexes, int):
             indexes = [indexes]
         if np.isscalar(indexes):
-            indexes = [indexes.item()] # noqa
+            indexes = [indexes.item()]  # noqa
         for idx in indexes:
             if idx not in range(len(self)):
                 if idx not in [-i for i in range(1, len(self) + 1, 1)]:
-                    raise IndexError(
-                        f"Index {idx} out of range of "
-                        f"AgMLDataLoader length: {len(self)}.")
+                    raise IndexError(f"Index {idx} out of range of " f"AgMLDataLoader length: {len(self)}.")
         return self._manager.get(resolve_list_value(indexes))
 
     def __iter__(self):
@@ -549,32 +577,32 @@ def task(self):
     @property
     def num_images(self):
         """Returns the number of images in the dataset."""
-        return self._meta_properties.get('num_images')
+        return self._meta_properties.get("num_images")
 
     @property
     def classes(self):
         """Returns the classes that the dataset is predicting."""
-        return self._meta_properties.get('classes')
+        return self._meta_properties.get("classes")
 
     @property
     def num_classes(self):
         """Returns the number of classes in the dataset."""
-        return self._meta_properties.get('num_classes')
+        return self._meta_properties.get("num_classes")
 
     @property
     def num_to_class(self):
         """Returns a mapping from a number to a class label."""
-        return self._meta_properties.get('num_to_class')
+        return self._meta_properties.get("num_to_class")
 
     @property
     def class_to_num(self):
         """Returns a mapping from a class label to a number."""
-        return self._meta_properties.get('class_to_num')
+        return self._meta_properties.get("class_to_num")
 
     @property
     def data_distributions(self):
         """Displays the distribution of images from each source."""
-        return self._meta_properties.get('data_distributions')
+        return self._meta_properties.get("data_distributions")
 
     @property
     def image_size(self):
@@ -586,68 +614,62 @@ def image_size(self):
         """
         return self._manager._resize_manager.size
 
-    def _generate_split_loader(
-            self, contents, split, meta_properties = None, **kwargs):
+    def _generate_split_loader(self, contents, split, meta_properties=None, **kwargs):
         """Generates a split `AgMLDataLoader`."""
         # Check if the data split exists.
         if contents is None:
-            raise ValueError(
-                f"Attempted to access '{split}' split when "
-                f"the data has not been split for '{split}'.")
+            raise ValueError(f"Attempted to access '{split}' split when " f"the data has not been split for '{split}'.")
 
         # Load a new `DataManager` and update its internal managers
         # using the state of the existing loader's `DataManager`.
         builder = DataBuilder.from_data(
-            contents = [contents, kwargs.get('labels_for_image', None)],
-            info = self.info,
-            root = self.dataset_root,
-            builder = self._builder)
+            contents=[contents, kwargs.get("labels_for_image", None)],
+            info=self.info,
+            root=self.dataset_root,
+            builder=self._builder,
+        )
         current_manager = copy.deepcopy(self._manager.__getstate__())
-        current_manager.pop('builder')
-        current_manager['builder'] = builder
+        current_manager.pop("builder")
+        current_manager["builder"] = builder
 
         # Build the new accessors and construct the `DataManager`.
         accessors = np.arange(len(builder.get_contents()))
         if self._manager._shuffle:
             np.random.shuffle(accessors)
-        current_manager['accessors'] = accessors
-        batch_size = current_manager.pop('batch_size')
-        current_manager['batch_size'] = None
+        current_manager["accessors"] = accessors
+        batch_size = current_manager.pop("batch_size")
+        current_manager["batch_size"] = None
         new_manager = DataManager.__new__(DataManager)
         new_manager.__setstate__(current_manager)
 
         # After the builder and accessors have been generated, we need
         # to generate a new list of `DataObject`s.
-        new_manager._create_objects(
-            new_manager._builder, self.task)
+        new_manager._create_objects(new_manager._builder, self.task)
 
         # Update the `TransformManager` and `ResizeManager` of the
         # `TrainManager` in the `DataManager` (they need to be synchronized).
-        new_manager._train_manager._transform_manager = \
-            new_manager._transform_manager
-        new_manager._train_manager._resize_manager = \
-            new_manager._resize_manager
+        new_manager._train_manager._transform_manager = new_manager._transform_manager
+        new_manager._train_manager._resize_manager = new_manager._resize_manager
 
         # Batching data needs to be done independently.
         if batch_size is not None:
-            new_manager.batch_data(batch_size = batch_size)
+            new_manager.batch_data(batch_size=batch_size)
 
         # Update the metadata parameters.
         if meta_properties is None:
             meta_properties = self._meta_properties.copy()
-            meta_properties['num_images'] = len(contents)
-            meta_properties['data_distributions'] = {
-                self.name: len(contents)}
+            meta_properties["num_images"] = len(contents)
+            meta_properties["data_distributions"] = {self.name: len(contents)}
 
         # Instantiate a new `AgMLDataLoader` from the contents.
         loader_state = self.copy().__getstate__()
-        loader_state['builder'] = builder
-        loader_state['manager'] = new_manager
-        loader_state['meta_properties'] = meta_properties
+        loader_state["builder"] = builder
+        loader_state["manager"] = new_manager
+        loader_state["meta_properties"] = meta_properties
         cls = super(AgMLDataLoader, self).__new__(AgMLDataLoader)
         cls.__setstate__(loader_state)
-        for attr in ['train', 'val', 'test']:
-            setattr(cls, f'_{attr}_data', None)
+        for attr in ["train", "val", "test"]:
+            setattr(cls, f"_{attr}_data", None)
         cls._is_split = True
         return cls
 
@@ -656,8 +678,7 @@ def train_data(self):
         """Stores the `train` split of the data in the loader."""
         if isinstance(self._train_data, AgMLDataLoader):
             return self._train_data
-        self._train_data = self._generate_split_loader(
-            self._train_content, split = 'train')
+        self._train_data = self._generate_split_loader(self._train_content, split="train")
         return self._train_data
 
     @property
@@ -665,8 +686,7 @@ def val_data(self):
         """Stores the `val` split of the data in the loader."""
         if isinstance(self._val_data, AgMLDataLoader):
             return self._val_data
-        self._val_data = self._generate_split_loader(
-            self._val_content, split = 'val')
+        self._val_data = self._generate_split_loader(self._val_content, split="val")
         self._val_data.eval()
         return self._val_data
 
@@ -675,8 +695,7 @@ def test_data(self):
         """Stores the `test` split of the data in the loader."""
         if isinstance(self._test_data, AgMLDataLoader):
             return self._test_data
-        self._test_data = self._generate_split_loader(
-            self._test_content, split = 'test')
+        self._test_data = self._generate_split_loader(self._test_content, split="test")
         self._test_data.eval()
         return self._test_data
 
@@ -703,7 +722,7 @@ def eval(self) -> "AgMLDataLoader":
         -------
         The `AgMLDataLoader` object.
         """
-        self._manager.update_train_state('eval')
+        self._manager.update_train_state("eval")
         return self
 
     def disable_preprocessing(self) -> "AgMLDataLoader":
@@ -778,8 +797,8 @@ def as_keras_sequence(self) -> "AgMLDataLoader":
         The `AgMLDataLoader` object.
         """
 
-        _add_dataset_to_mro(self, 'tf')
-        self._manager.update_train_state('tf')
+        _add_dataset_to_mro(self, "tf")
+        self._manager.update_train_state("tf")
         return self
 
     def as_torch_dataset(self) -> "AgMLDataLoader":
@@ -807,8 +826,8 @@ def as_torch_dataset(self) -> "AgMLDataLoader":
         -------
         The `AgMLDataLoader` object.
         """
-        _add_dataset_to_mro(self, 'torch')
-        self._manager.update_train_state('torch')
+        _add_dataset_to_mro(self, "torch")
+        self._manager.update_train_state("torch")
         return self
 
     @property
@@ -831,11 +850,11 @@ def shuffle_data(self, value):
             raise TypeError("Expected either `True` or `False` for 'shuffle_data'.")
         self._manager._shuffle = value
 
-    def shuffle(self, seed = None):
+    def shuffle(self, seed=None):
         """Potentially shuffles the contents of the loader.
-        
+
         If shuffling is enabled on this loader (`shuffle = False` has
-        not been passed to the instantiation), then this method will  
+        not been passed to the instantiation), then this method will
         shuffle the order of contents in it. A seed can be provided to
         shuffle the dataset to an expected order.
 
@@ -848,7 +867,7 @@ def shuffle(self, seed = None):
         unless the `shuffle = False` parameter is passed at instantiation.
         However, this disables automatic shuffling for the class
         permanently, and this method must be called to shuffle the data.
-        
+
         Parameters
         ----------
         seed : int, optional
@@ -858,7 +877,7 @@ def shuffle(self, seed = None):
         -------
         The `AgMLDataLoader` object.
         """
-        self._manager.shuffle(seed = seed)
+        self._manager.shuffle(seed=seed)
         return self
 
     def take_images(self):
@@ -874,6 +893,7 @@ def take_images(self):
         An `agml.data.ImageLoader` with the dataset images.
         """
         from agml.data.image_loader import ImageLoader
+
         return ImageLoader(self)
 
     def take_dataset(self, name) -> "AgMLDataLoader":
@@ -897,10 +917,9 @@ def take_dataset(self, name) -> "AgMLDataLoader":
         -------
         An `AgMLDataLoader`.
         """
-        raise ValueError(
-            "The `loader.take_dataset` method only works for multi-dataset loaders.")
+        raise ValueError("The `loader.take_dataset` method only works for multi-dataset loaders.")
 
-    def take_class(self, classes, reindex = True) -> "AgMLDataLoader":
+    def take_class(self, classes, reindex=True) -> "AgMLDataLoader":
         """Reduces the dataset to a subset of class labels.
 
         This method, given a set of either integer or string class labels,
@@ -929,24 +948,26 @@ def take_class(self, classes, reindex = True) -> "AgMLDataLoader":
         -----
         This method only works for object detection datasets.
         """
-        if self._info.tasks.ml != 'object_detection':
-            raise RuntimeError("The `take_class` method can only be "
-                               "used for object detection datasets.")
+        if self._info.tasks.ml != "object_detection":
+            raise RuntimeError("The `take_class` method can only be " "used for object detection datasets.")
 
         # Parse the provided classes and determine their numerical labels.
         if isinstance(classes, str):
             if classes not in self.classes:
                 raise ValueError(
                     f"Received a class '{classes}' for `loader.take_class`, "
-                    f"which is not in the classes for {self.name}: {self.classes}")
+                    f"which is not in the classes for {self.name}: {self.classes}"
+                )
             classes = [self.class_to_num[classes]]
         elif isinstance(classes, int):
-            try: self.num_to_class[classes]
+            try:
+                self.num_to_class[classes]
             except IndexError:
                 raise ValueError(
                     f"The provided class number {classes} is out of "
                     f"range for {self.num_classes} classes. Make sure "
-                    f"you are using zero-indexing.")
+                    f"you are using zero-indexing."
+                )
             classes = [classes]
         else:
             parsed_classes = []
@@ -955,7 +976,8 @@ def take_class(self, classes, reindex = True) -> "AgMLDataLoader":
                     if cls not in self.classes:
                         raise ValueError(
                             f"Received a class '{cls}' for `loader.take_class`, which "
-                            f"is not in the classes for {self.name}: {self.classes}")
+                            f"is not in the classes for {self.name}: {self.classes}"
+                        )
                     parsed_classes.append(self.class_to_num[cls])
             elif isinstance(classes[0], int):
                 for cls in classes:
@@ -965,7 +987,8 @@ def take_class(self, classes, reindex = True) -> "AgMLDataLoader":
                         raise ValueError(
                             f"The provided class number {cls} is out of "
                             f"range for {self.num_classes} classes. Make "
-                            f"sure you are using zero-indexing.")
+                            f"sure you are using zero-indexing."
+                        )
                     parsed_classes.append(cls)
             classes = parsed_classes.copy()
 
@@ -974,16 +997,14 @@ def take_class(self, classes, reindex = True) -> "AgMLDataLoader":
         if not all(len(np.unique(c)) == 1 for c in categories.values()):
             raise ValueError(
                 f"Dataset {self.name} has images with multiple categories for "
-                f"bounding boxes, cannot take an individual set of classes.")
+                f"bounding boxes, cannot take an individual set of classes."
+            )
 
         # Get the new data which will go in the loader. The `DataBuilder`
         # stores a mapping of category IDs corresponding to the bounding
         # boxes in each image, so we use these to determine the new boxes.
-        new_category_map = {
-            k: v for k, v in categories.items() if v[0] in classes}
-        new_coco_map = {
-            k: v for k, v in self._builder._data.items()
-            if k in new_category_map.keys()}
+        new_category_map = {k: v for k, v in categories.items() if v[0] in classes}
+        new_coco_map = {k: v for k, v in self._builder._data.items() if k in new_category_map.keys()}
 
         # Create the new info parameters for the class. If reindexing
         # is requested, then we re-index the classes based on the order
@@ -993,31 +1014,37 @@ def take_class(self, classes, reindex = True) -> "AgMLDataLoader":
             old_to_new = {cls: idx + 1 for idx, cls in enumerate(classes)}
             new_classes = [self.num_to_class[c] for c in classes]
             new_properties = {
-                'num_images': len(new_coco_map.keys()),
-                'classes': new_classes,
-                'num_classes': len(new_classes),
-                'num_to_class': {i + 1: c for i, c in enumerate(new_classes)},
-                'class_to_num': {c: i + 1 for i, c in enumerate(new_classes)}}
+                "num_images": len(new_coco_map.keys()),
+                "classes": new_classes,
+                "num_classes": len(new_classes),
+                "num_to_class": {i + 1: c for i, c in enumerate(new_classes)},
+                "class_to_num": {c: i + 1 for i, c in enumerate(new_classes)},
+            }
         else:
             new_classes = [self.num_to_class[c] for c in classes]
             new_properties = {
-                'num_images': len(new_coco_map.keys()),
-                'classes': new_classes,
-                'num_classes': len(classes),
-                'num_to_class': {c: self.num_to_class[c] for c in classes},
-                'class_to_num': {self.num_to_class[c]: c for c in classes}}
+                "num_images": len(new_coco_map.keys()),
+                "classes": new_classes,
+                "num_classes": len(classes),
+                "num_to_class": {c: self.num_to_class[c] for c in classes},
+                "class_to_num": {self.num_to_class[c]: c for c in classes},
+            }
 
         # Create the new loader.
         obj = self._generate_split_loader(
-            new_coco_map, 'train',
-            meta_properties = new_properties,
-            labels_for_image = new_category_map)
+            new_coco_map,
+            "train",
+            meta_properties=new_properties,
+            labels_for_image=new_category_map,
+        )
         obj._is_split = False
 
         # Re-index the loader if requested to.
         if reindex:
+
             class AnnotationRemap(AgMLSerializable):
                 """A helper class to remap annotation labels for multiple datasets."""
+
                 serializable = frozenset(("map",))
 
                 def __init__(self, o2n):
@@ -1028,15 +1055,14 @@ def __call__(self, contents, name):
                     image, annotations = contents
 
                     # Re-map the annotation ID.
-                    category_ids = annotations['category_id']
+                    category_ids = annotations["category_id"]
                     category_ids[np.where(category_ids == 0)[0]] = 1  # fix
                     new_ids = np.array([self._map[c] for c in category_ids])
-                    annotations['category_id'] = new_ids
+                    annotations["category_id"] = new_ids
                     return image, annotations
 
             # Maps the annotations.
-            obj._manager._train_manager._set_annotation_remap_hook(
-                AnnotationRemap(old_to_new)) # noqa
+            obj._manager._train_manager._set_annotation_remap_hook(AnnotationRemap(old_to_new))  # noqa
 
         # Return the loader.
         return obj
@@ -1071,9 +1097,7 @@ def take_random(self, k) -> "AgMLDataLoader":
         if isinstance(k, float):
             # Check that 0.0 <= k <= 1.0.
             if not 0.0 <= k <= 1.0:
-                raise ValueError(
-                    "If passing a proportion to `take_class`, "
-                    "it should be in range [0.0, 1.0].")
+                raise ValueError("If passing a proportion to `take_class`, " "it should be in range [0.0, 1.0].")
 
             # Convert the proportion float to an absolute int. Note that
             # the method used is rounding up to the nearest int for cases
@@ -1090,7 +1114,8 @@ def take_random(self, k) -> "AgMLDataLoader":
             if not 0 <= k <= self.num_images:
                 raise ValueError(
                     f"Received a request to take a random sampling of "
-                    f"{k} images, when the dataset has {self.num_images}.")
+                    f"{k} images, when the dataset has {self.num_images}."
+                )
 
             # We use a similar functionality to the `split` method here,
             # essentially choosing a random sampling up until `k` and then
@@ -1098,22 +1123,19 @@ def take_random(self, k) -> "AgMLDataLoader":
             split = np.arange(0, self.num_images)
             np.random.shuffle(split)
             indices = split[:k]
-            content = list(self._manager.generate_split_contents(
-                {'content': indices}).values())[0]
+            content = list(self._manager.generate_split_contents({"content": indices}).values())[0]
 
             # Create a new `AgMLDataLoader` from the new contents.
-            obj = self._generate_split_loader(content, 'train')
+            obj = self._generate_split_loader(content, "train")
             obj._is_split = False
             return obj
 
         # Otherwise, raise an error.
         else:
-            raise TypeError(
-                f"Expected only an int or a float when "
-                f"taking a random split, got {type(k)}.")
+            raise TypeError(f"Expected only an int or a float when " f"taking a random split, got {type(k)}.")
 
     @inject_random_state
-    def split(self, train = None, val = None, test = None, shuffle = True):
+    def split(self, train=None, val=None, test=None, shuffle=True):
         """Splits the data into train, val and test splits.
 
         By default, this method does nothing (or if the data has been
@@ -1150,11 +1172,10 @@ def split(self, train = None, val = None, test = None, shuffle = True):
             if self._is_split:
                 raise ValueError("Cannot split already split data.")
         elif self._manager._batch_size is not None:
-            raise ValueError("Cannot split already batched data. "
-                             "Split the data before batching.")
+            raise ValueError("Cannot split already batched data. " "Split the data before batching.")
 
         # If no parameters are passed, then don't do anything.
-        arg_dict = {'train': train, 'val': val, 'test': test}
+        arg_dict = {"train": train, "val": val, "test": test}
         valid_args = {k: v for k, v in arg_dict.items() if v is not None}
         if all(i is None for i in arg_dict.values()):
             return None
@@ -1167,11 +1188,12 @@ def split(self, train = None, val = None, test = None, shuffle = True):
         if all(isinstance(i, float) for i in valid_args.values()):
             # To prevent potential precision errors, we need to convert the
             # splits to `Decimal` objects and then set the decimal precision.
-            getcontext().prec = 4 # noqa
+            getcontext().prec = 4  # noqa
             valid_args = {k: Decimal(v) / Decimal(1) for k, v in valid_args.items()}
             if not sum(valid_args.values()) == Decimal(1):
-                raise ValueError(f"Got floats for input splits and expected a sum "
-                                 f"of 1, instead got {sum(valid_args.values())}.")
+                raise ValueError(
+                    f"Got floats for input splits and expected a sum " f"of 1, instead got {sum(valid_args.values())}."
+                )
 
             # Convert the splits from floats to ints. If the sum of the int
             # splits are greater than the total number of data, then the largest
@@ -1180,9 +1202,7 @@ def split(self, train = None, val = None, test = None, shuffle = True):
             proportions = {k: int(v * Decimal(num_images)) for k, v in valid_args.items()}
             if sum(proportions.values()) != num_images:
                 diff = sum(proportions.values()) - num_images
-                largest_split = list(proportions.keys())[
-                    list(proportions.values()).index(
-                        max(proportions.values()))]
+                largest_split = list(proportions.keys())[list(proportions.values()).index(max(proportions.values()))]
                 proportions[largest_split] = proportions[largest_split] - diff
             valid_args = proportions.copy()
 
@@ -1190,9 +1210,11 @@ def split(self, train = None, val = None, test = None, shuffle = True):
         if all(isinstance(i, int) for i in valid_args.values()):
             # Ensure that the sum of the splits is the length of the dataset.
             if not sum(valid_args.values()) == self.num_images:
-                raise ValueError(f"Got ints for input splits and expected a sum "
-                                 f"equal to the dataset length, {self.num_images},"
-                                 f"but instead got {sum(valid_args.values())}.")
+                raise ValueError(
+                    f"Got ints for input splits and expected a sum "
+                    f"equal to the dataset length, {self.num_images},"
+                    f"but instead got {sum(valid_args.values())}."
+                )
 
             # The splits will be generated as sequences of indices.
             generated_splits = {}
@@ -1208,14 +1230,12 @@ def split(self, train = None, val = None, test = None, shuffle = True):
             if len(valid_args) == 1:
                 generated_splits[names[0]] = split
             elif len(valid_args) == 2:
-                generated_splits = {k: v for k, v in zip(
-                    names, [split[:splits[0]], split[splits[0]:]])}
+                generated_splits = {k: v for k, v in zip(names, [split[: splits[0]], split[splits[0] :]])}
             else:
-                split_1 = split[:splits[0]]
-                split_2 = split[splits[0]: splits[0] + splits[1]]
-                split_3 = split[splits[0] + splits[1]:]
-                generated_splits = {k: v for k, v in zip(
-                    names, [split_1, split_2, split_3])}
+                split_1 = split[: splits[0]]
+                split_2 = split[splits[0] : splits[0] + splits[1]]
+                split_3 = split[splits[0] + splits[1] :]
+                generated_splits = {k: v for k, v in zip(names, [split_1, split_2, split_3])}
 
             # Get the actual split contents from the manager. These contents are
             # not `DataObject`s, rather they are simply the actual mapping of
@@ -1224,20 +1244,20 @@ def split(self, train = None, val = None, test = None, shuffle = True):
 
             # Build new `DataBuilder`s and `DataManager`s for the split data.
             for split, content in contents.items():
-                setattr(self, f'_{split}_content', content)
+                setattr(self, f"_{split}_content", content)
 
         # Otherwise, raise an error for an invalid type.
         else:
             raise TypeError(
                 "Expected either only ints or only floats when generating "
-                f"a data split, got {[type(i) for i in arg_dict.values()]}.")
+                f"a data split, got {[type(i) for i in arg_dict.values()]}."
+            )
 
     def _is_split_generated(self):
         """Check if a data split has been generated (not necessarily accessed)"""
-        return any(getattr(self, f'_{split}_content')
-                   is not None for split in ['train', 'val', 'test'])
+        return any(getattr(self, f"_{split}_content") is not None for split in ["train", "val", "test"])
 
-    def save_split(self, name, overwrite = False):
+    def save_split(self, name, overwrite=False):
         """Saves the current split of data to an internal location.
 
         This method can be used to save the current split of data to an
@@ -1255,47 +1275,41 @@ def save_split(self, name, overwrite = False):
             Whether to overwrite an existing split with the same name.
         """
         # Ensure that there exist data splits (train/val/test data).
-        if (
-                self._train_content is None
-                and self._val_content is None
-                and self._test_content is None
-        ):
-            raise NotImplementedError("Cannot save a split of data when no "
-                                      "split has been generated.")
+        if self._train_content is None and self._val_content is None and self._test_content is None:
+            raise NotImplementedError("Cannot save a split of data when no " "split has been generated.")
 
         # Get each of the individual splits, and for semantic segmentation/image
         # classification, remove the full paths and only save the path relative
         # to the dataset root (so only the file and its directory are saved).
         splits = {}
-        if self._info.tasks.ml == 'image_classification':
-            for split in ['train', 'val', 'test']:
-                contents = getattr(self, f'_{split}_content')
+        if self._info.tasks.ml == "image_classification":
+            for split in ["train", "val", "test"]:
+                contents = getattr(self, f"_{split}_content")
                 if contents is not None:
-                    contents = {
-                        os.path.relpath(c, self.dataset_root): v for c, v in contents.items()
-                    }
+                    contents = {os.path.relpath(c, self.dataset_root): v for c, v in contents.items()}
                 splits[split] = contents
-        elif self._info.tasks.ml == 'semantic_segmentation':
-            for split in ['train', 'val', 'test']:
-                contents = getattr(self, f'_{split}_content')
+        elif self._info.tasks.ml == "semantic_segmentation":
+            for split in ["train", "val", "test"]:
+                contents = getattr(self, f"_{split}_content")
                 if contents is not None:
                     contents = {
-                        os.path.relpath(c, self.dataset_root):
-                            os.path.relpath(v, self.dataset_root) for c, v in contents.items()
+                        os.path.relpath(c, self.dataset_root): os.path.relpath(v, self.dataset_root)
+                        for c, v in contents.items()
                     }
                 splits[split] = contents
-        elif self._info.tasks.ml == 'object_detection':
-            for split in ['train', 'val', 'test']:
-                contents = getattr(self, f'_{split}_content')
+        elif self._info.tasks.ml == "object_detection":
+            for split in ["train", "val", "test"]:
+                contents = getattr(self, f"_{split}_content")
                 splits[split] = contents
 
         # Save the split to the internal location.
-        split_dir = os.path.join(SUPER_BASE_DIR, 'splits', self.name)
-        os.makedirs(split_dir, exist_ok = True)
-        if os.path.exists(os.path.join(split_dir, f'{name}.json')):
+        split_dir = os.path.join(SUPER_BASE_DIR, "splits", self.name)
+        os.makedirs(split_dir, exist_ok=True)
+        path_split = os.path.join(split_dir, f"{name}.json")
+        if os.path.exists(path_split):
             if not overwrite:
                 raise FileExistsError(f"A split with the name {name} already exists.")
-        with open(os.path.join(split_dir, f'{name}.json'), 'w') as f:
+        with open(path_split, "w") as f:
             json.dump(splits, f)
 
     def load_split(self, name, **kwargs):
@@ -1318,19 +1332,19 @@ def load_split(self, name, **kwargs):
             The name of the split to load. This name will be used to identify
             the split to load.
         """
-        if kwargs.get('manual_split_set', False):
-            splits = kwargs['manual_split_set']
+        if kwargs.get("manual_split_set", False):
+            splits = kwargs["manual_split_set"]
 
         else:
             # Ensure that the split exists.
-            split_dir = os.path.join(SUPER_BASE_DIR, 'splits', self.name)
-            if not os.path.exists(os.path.join(split_dir, f'{name}.json')):
-                split_dir = os.path.join(self.dataset_root, '.splits')
-                if not os.path.exists(os.path.join(split_dir, f'{name}.json')):
+            split_dir = os.path.join(SUPER_BASE_DIR, "splits", self.name)
+            if not os.path.exists(os.path.join(split_dir, f"{name}.json")):
+                split_dir = os.path.join(self.dataset_root, ".splits")
+                if not os.path.exists(os.path.join(split_dir, f"{name}.json")):
                     raise FileNotFoundError(f"Could not find a split with the name {name}.")
 
             # Load the split from the internal location.
-            with open(os.path.join(split_dir, f'{name}.json'), 'r') as f:
+            with open(os.path.join(split_dir, f"{name}.json"), "r") as f:
                 splits = json.load(f)
 
         # Set the split contents.
@@ -1340,11 +1354,9 @@ def load_split(self, name, **kwargs):
             if len(content) > 0:
                 first_item = list(content.items())[0]
                 if not os.path.isabs(first_item[0]):  # backwards compatibility
-                    if self._info.tasks.ml == 'image_classification':
-                        content = {
-                            os.path.join(self.dataset_root, c): v for c, v in content.items()
-                        }
-                    elif self._info.tasks.ml == 'semantic_segmentation':
+                    if self._info.tasks.ml == "image_classification":
+                        content = {os.path.join(self.dataset_root, c): v for c, v in content.items()}
+                    elif self._info.tasks.ml == "semantic_segmentation":
                         content = {
                             os.path.join(self.dataset_root, c): os.path.join(self.dataset_root, v)
                             for c, v in content.items()
@@ -1352,9 +1364,9 @@ def load_split(self, name, **kwargs):
             else:
                 content = None
 
-            setattr(self, f'_{split}_content', content)
+            setattr(self, f"_{split}_content", content)
 
-    def batch(self, batch_size = None):
+    def batch(self, batch_size=None):
         """Batches sets of image and annotation data according to a size.
 
         This method will group sets of data together into batches of size
@@ -1379,11 +1391,9 @@ def batch(self, batch_size = None):
         -----
         The last batch will be of size <= `batch_size`.
         """
-        self._manager.batch_data(
-            batch_size = batch_size
-        )
+        self._manager.batch_data(batch_size=batch_size)
 
-    def resize_images(self, image_size = None, method = 'bilinear'):
+    def resize_images(self, image_size=None, method="bilinear"):
         """Resizes images within the loader to a specified size.
 
         This method applies a resizing parameter for images before they are
@@ -1427,15 +1437,14 @@ def resize_images(self, image_size = None, method = 'bilinear'):
         If a transform pipeline is provided, images will be resized
         *before* being passed into the transform pipeline.
         """
-        self._manager.assign_resize(
-            image_size = image_size,
-            method = method
-        )
-
-    def transform(self,
-                  transform = NoArgument,
-                  target_transform = NoArgument,
-                  dual_transform = NoArgument):
+        self._manager.assign_resize(image_size=image_size, method=method)
+
+    def transform(
+        self,
+        transform=NoArgument,
+        target_transform=NoArgument,
+        dual_transform=NoArgument,
+    ):
         """Applies vision transforms to the input image and annotation data.
 
         This method applies transformations to the image and annotation data
@@ -1503,12 +1512,12 @@ def transform(self,
           `transform` argument and they will automatically be applied.
         """
         self._manager.push_transforms(
-            transform = transform,
-            target_transform = target_transform,
-            dual_transform = dual_transform
+            transform=transform,
+            target_transform=target_transform,
+            dual_transform=dual_transform,
         )
 
-    def normalize_images(self, method = 'scale'):
+    def normalize_images(self, method="scale"):
         """Converts images from 0-255 integers to 0-1 floats and normalizes.
 
         This is a convenience method to convert all images from integer-valued
@@ -1542,23 +1551,21 @@ def normalize_images(self, method = 'scale'):
         This method is not implicitly called when converting to PyTorch/TensorFlow
         mode, it needs to be manually called even if you just want 0-1 scaled images.
         """
-        if method not in ['scale', 'imagenet', 'standard', None]:
+        if method not in ["scale", "imagenet", "standard", None]:
             raise ValueError(f"Received invalid normalization method: '{method}'.")
 
-        if method == 'scale':
-            normalization_params = 'scale'
-        elif method == 'imagenet':
-            normalization_params = 'imagenet'
-        elif method == 'standard':
+        if method == "scale":
+            normalization_params = "scale"
+        elif method == "imagenet":
+            normalization_params = "imagenet"
+        elif method == "standard":
             normalization_params = self._info.image_stats
         else:
             normalization_params = None
 
-        self.transform(
-            transform = ('normalize', normalization_params)
-        )
+        self.transform(transform=("normalize", normalization_params))
 
-    def labels_to_one_hot(self, add = True):
+    def labels_to_one_hot(self, add=True):
         """Converts image classification numerical labels to one-hot labels.
 
         This is a convenience method to apply one-hot vector transformations
@@ -1574,15 +1581,12 @@ def labels_to_one_hot(self, add = True):
             which adds the one-hot label transformation.
 
         """
-        if self._info.tasks.ml != 'image_classification':
-            raise RuntimeError("The `one_hot` label transformation can only "
-                               "be used for image classification tasks.")
+        if self._info.tasks.ml != "image_classification":
+            raise RuntimeError("The `one_hot` label transformation can only " "be used for image classification tasks.")
 
-        self.transform(
-            target_transform = ('one_hot', self._info.num_classes, add)
-        )
+        self.transform(target_transform=("one_hot", self._info.num_classes, add))
 
-    def mask_to_channel_basis(self, add = True):
+    def mask_to_channel_basis(self, add=True):
         """Converts semantic segmentation masks to channel-wise.
 
         This is a convenience method to convert integer-labeled semantic
@@ -1601,19 +1605,20 @@ def mask_to_channel_basis(self, add = True):
             label transformation from the manager. This is `True` by default,
             which adds the one-hot label transformation.
         """
-        if self._info.tasks.ml != 'semantic_segmentation':
-            raise ValueError("The `mask_to_channel_basis` transformation "
-                             "can only be used for semantic segmentation tasks.")
+        if self._info.tasks.ml != "semantic_segmentation":
+            raise ValueError(
+                "The `mask_to_channel_basis` transformation " "can only be used for semantic segmentation tasks."
+            )
 
         # Warn about binary segmentation tasks.
         if self._info.num_classes == 1:
-            log(f"No mask-to-channel transformation will be applied for "
-                f"a binary segmentation task (dataset {self.name}).")
+            log(
+                f"No mask-to-channel transformation will be applied for "
+                f"a binary segmentation task (dataset {self.name})."
+            )
             return
 
-        self.transform(
-            target_transform = ('channel_basis', self._info.num_classes, add)
-        )
+        self.transform(target_transform=("channel_basis", self._info.num_classes, add))
 
     def generalize_class_detections(self):
         """Generalizes object detection classes to a single class.
@@ -1627,10 +1632,9 @@ def generalize_class_detections(self):
         This method is intended to be used for multi-dataset loaders,
         and will raise an error if using with a single-dataset loader.
         """
-        raise ValueError(
-            "This method can only be used with multi-dataset loaders.")
+        raise ValueError("This method can only be used with multi-dataset loaders.")
 
-    def export_contents(self, export_format = None):
+    def export_contents(self, export_format=None):
         """Exports the internal contents of the `AgMLDataLoader`.
 
         This method serves as a hook for high-level users who simply want
@@ -1661,9 +1665,7 @@ def export_contents(self, export_format = None):
         -------
         The raw contents of the dataset.
         """
-        return self._builder.export_contents(
-            export_format = export_format
-        )
+        return self._builder.export_contents(export_format=export_format)
 
     def export_tensorflow(self):
         """Exports the contents of the loader in a native TensorFlow dataset.
@@ -1710,31 +1712,25 @@ def export_tensorflow(self):
         """
         # Update the backend management system.
         from agml.data.exporters.tensorflow import TFExporter
-        if get_backend() != 'tf':
+
+        if get_backend() != "tf":
             if user_changed_backend():
-                raise StrictBackendError(
-                    change = 'tf', obj = self.export_tensorflow)
-            set_backend('tf')
+                raise StrictBackendError(change="tf", obj=self.export_tensorflow)
+            set_backend("tf")
 
         # Build the exporter.
-        exporter = TFExporter(
-            task = self.info.tasks.ml,
-            builder = self._builder
-        )
+        exporter = TFExporter(task=self.info.tasks.ml, builder=self._builder)
 
         # Update the current state of the loader.
-        exporter.assign_state(state = self._manager._train_manager.state)
+        exporter.assign_state(state=self._manager._train_manager.state)
 
         # Parse the transforms and resizing for the class.
         transforms = self._manager._transform_manager.get_transform_states()
         resizing = self._manager._resize_manager.size
-        exporter.digest_transforms(
-            transforms = transforms,
-            resizing = resizing
-        )
+        exporter.digest_transforms(transforms=transforms, resizing=resizing)
 
         # Construct and return the loader.
-        return exporter.build(batch_size = self._manager._batch_size)
+        return exporter.build(batch_size=self._manager._batch_size)
 
     def export_torch(self, **loader_kwargs):
         """Exports the contents of the loader in a native PyTorch loader.
@@ -1765,13 +1761,14 @@ def export_torch(self, **loader_kwargs):
         -------
         A `torch.utils.data.DataLoader` enclosing a copy of this loader.
         """
-        from agml.backend.tftorch import torch
         from torch.utils.data import DataLoader
-        if get_backend() != 'torch':
+
+        from agml.backend.tftorch import torch
+
+        if get_backend() != "torch":
             if user_changed_backend():
-                raise StrictBackendError(
-                    change = 'torch', obj = self.export_torch)
-            set_backend('torch')
+                raise StrictBackendError(change="torch", obj=self.export_torch)
+            set_backend("torch")
 
         # Make a copy of the `AgMLDataLoader` so the following changes
         # don't affect the original loader, just the new one.
@@ -1782,31 +1779,35 @@ def export_torch(self, **loader_kwargs):
 
         # The `DataLoader` automatically batches objects using its
         # own mechanism, so we remove batching from this DataLoader.
-        batch_size = loader_kwargs.pop('batch_size', obj._manager._batch_size)
+        batch_size = loader_kwargs.pop("batch_size", obj._manager._batch_size)
         obj.batch(None)
-        shuffle = loader_kwargs.pop('shuffle', obj._manager._shuffle)
+        shuffle = loader_kwargs.pop("shuffle", obj._manager._shuffle)
 
         # The `collate_fn` for object detection is different because
         # the COCO JSON dictionaries each have different formats. So,
         # we need to replace it with a custom function.
-        collate_fn = loader_kwargs.pop('collate_fn', None)
-        if obj.task == 'object_detection' and collate_fn is None:
-            if any('efficientdet' in i.__class__.__name__.lower() for i in
-                   self._manager._transform_manager.get_transform_states()['dual_transform']):
+        collate_fn = loader_kwargs.pop("collate_fn", None)
+        if obj.task == "object_detection" and collate_fn is None:
+            if any(
+                "efficientdet" in i.__class__.__name__.lower()
+                for i in self._manager._transform_manager.get_transform_states()["dual_transform"]
+            ):
                 from agml.backend.tftorch import collate_fn_efficientdet
+
                 collate_fn = collate_fn_efficientdet
             else:
                 from agml.backend.tftorch import collate_fn_basic
+
                 collate_fn = collate_fn_basic
 
         # Return the DataLoader with a copy of this AgMLDataLoader, so
         # that changes to this will not affect the returned loader.
         return DataLoader(
             obj,
-            batch_size = batch_size,
-            shuffle = shuffle,
-            collate_fn = collate_fn,
-            **loader_kwargs
+            batch_size=batch_size,
+            shuffle=shuffle,
+            collate_fn=collate_fn,
+            **loader_kwargs,
         )
 
     def export_yolo(self, yolo_path=None):
@@ -1826,12 +1827,11 @@ def export_yolo(self, yolo_path=None):
         -------
         The path to the saved YOLO-formatted dataset.
         """
-        if self._info.tasks.ml != 'object_detection':
-            raise ValueError("The `export_yolo` method can only be used for "
-                             "object detection tasks.")
+        if self._info.tasks.ml != "object_detection":
+            raise ValueError("The `export_yolo` method can only be used for " "object detection tasks.")
         return export_yolo(self, yolo_path=yolo_path)
 
-    def show_sample(self, image_only = False, no_show = False):
+    def show_sample(self, image_only=False, no_show=False):
         """Shows a single data sample from the dataset.
 
         This method generates a data sample from the dataset with an image and
@@ -1857,17 +1857,4 @@ def show_sample(self, image_only = False, no_show = False):
             annotations = annotations[0]
 
         # Show the sample.
-        show_sample(self,
-                    image_only = image_only,
-                    no_show = no_show,
-                    sample = (image, annotations))
-
-
-
-
-
-
-
-
-
-
+        show_sample(self, image_only=image_only, no_show=no_show, sample=(image, annotations))
diff --git a/agml/data/manager.py b/agml/data/manager.py
index c32171f7..9fb87a8d 100644
--- a/agml/data/manager.py
+++ b/agml/data/manager.py
@@ -14,19 +14,18 @@
 
 import numpy as np
 
-from agml.framework import AgMLSerializable
-from agml.data.object import DataObject
+from agml.backend.tftorch import convert_to_batch, is_array_like
 from agml.data.builder import DataBuilder
-from agml.data.metadata import DatasetMetadata
-from agml.data.managers.transforms import TransformManager
 from agml.data.managers.resize import ImageResizeManager
 from agml.data.managers.training import TrainingManager
-
+from agml.data.managers.transforms import TransformManager
+from agml.data.metadata import DatasetMetadata
+from agml.data.object import DataObject
+from agml.framework import AgMLSerializable
 from agml.utils.general import NoArgument
-from agml.backend.tftorch import convert_to_batch, is_array_like
-from agml.utils.random import seed_context
 from agml.utils.image import consistent_shapes
 from agml.utils.logging import log
+from agml.utils.random import seed_context
 
 
 class DataManager(AgMLSerializable):
@@ -47,10 +46,22 @@ class DataManager(AgMLSerializable):
     Another way to think about the `DataManager` is it being a list
     of `DataObjects`, with extra logic for processing.
     """
-    serializable = frozenset((
-        'data_objects', 'resize_manager', 'accessors', 'task',
-        'dataset_name', 'shuffle', 'batch_size', 'dataset_root',
-        'transform_manager', 'builder', 'train_manager'))
+
+    serializable = frozenset(
+        (
+            "data_objects",
+            "resize_manager",
+            "accessors",
+            "task",
+            "dataset_name",
+            "shuffle",
+            "batch_size",
+            "dataset_root",
+            "transform_manager",
+            "builder",
+            "train_manager",
+        )
+    )
 
     def __init__(self, builder, task, name, root, **kwargs):
         # Set the basic class information.
@@ -60,27 +71,22 @@ def __init__(self, builder, task, name, root, **kwargs):
 
         # Create the `DataObject`s from the `DataBuilder`.
         if not isinstance(builder, DataBuilder):
-            builder = DataBuilder.from_data(
-                contents = builder,
-                info = DatasetMetadata(name),
-                root = root)
+            builder = DataBuilder.from_data(contents=builder, info=DatasetMetadata(name), root=root)
         self._builder = builder
         self._create_objects(self._builder, task)
 
         # Set up the internal transform managers. These control
         # the application of transformations to the input data.
-        self._transform_manager = TransformManager(task = task)
-        self._resize_manager = ImageResizeManager(
-            task = task, dataset = name, root = root
-        )
+        self._transform_manager = TransformManager(task=task)
+        self._resize_manager = ImageResizeManager(task=task, dataset=name, root=root)
 
         # The transform and resize managers are wrapped inside of a
         # `TrainingManager`, which controls the application of
         # preprocessing to the data based on the class state.
         self._train_manager = TrainingManager(
-            transform_manager = self._transform_manager,
-            resize_manager = self._resize_manager,
-            task = task
+            transform_manager=self._transform_manager,
+            resize_manager=self._resize_manager,
+            task=task,
         )
 
         # While we store data in the list of `DataObject`s, the actual
@@ -102,7 +108,7 @@ def __init__(self, builder, task, name, root, **kwargs):
         # The following parameters store various parameters which are
         # used internally or accessed by the `AgMLDataLoader` externally.
         self._batch_size = None
-        self._shuffle = kwargs.get('shuffle', True)
+        self._shuffle = kwargs.get("shuffle", True)
         self._maybe_shuffle()
 
     def data_length(self):
@@ -121,26 +127,23 @@ def _create_objects(self, builder, task):
         """
         self._data_objects = []
         contents = builder.get_contents()
-        if 'inputs' in contents.keys():
-            contents = zip(tuple(contents['inputs']),
-                           tuple(contents['outputs']))
+        if "inputs" in contents.keys():
+            contents = zip(tuple(contents["inputs"]), tuple(contents["outputs"]))
         else:
             contents = contents.items()
         for content in list(contents):
-            self._data_objects.append(DataObject.create(
-                contents = content, task = task,
-                root = self._dataset_root))
+            self._data_objects.append(DataObject.create(contents=content, task=task, root=self._dataset_root))
 
-    def _maybe_shuffle(self, seed = None):
+    def _maybe_shuffle(self, seed=None):
         """Wraps automatic shuffling to see if it is enabled or not."""
         if self._shuffle:
-            self.shuffle(seed = seed)
+            self.shuffle(seed=seed)
 
     def update_train_state(self, state):
         """Updates the training state in the `TrainingManager`."""
         self._train_manager.update_state(state)
 
-    def shuffle(self, seed = None):
+    def shuffle(self, seed=None):
         """Shuffles the contents of the `DataManager`.
 
         This method simply shuffles the order of the `DataObject`s
@@ -161,9 +164,8 @@ def generate_split_contents(self, splits):
         which are returned back to the `AgMLDataLoader` to be constructed into
         `DataBuilder`s and wrapped into new `DataManager`s.
         """
-        if self._task == 'object_detection':
-            contents = np.array(list(
-                self._builder.get_contents().items()), dtype = object)
+        if self._task == "object_detection":
+            contents = np.array(list(self._builder.get_contents().items()), dtype=object)
         else:
             contents = np.array(list(self._builder.get_contents().items()))
         try:
@@ -172,7 +174,8 @@ def generate_split_contents(self, splits):
             raise Exception(
                 f"Could not generate split contents, likely due to an error "
                 f"with the metadata for the dataset `{self._dataset_name}`. "
-                f"Please raise this error with the AgML team.")
+                f"Please raise this error with the AgML team."
+            )
 
     def batch_data(self, batch_size):
         """Batches the data into consistent groups.
@@ -206,40 +209,42 @@ def batch_data(self, batch_size):
         overflow = len(self._accessors) - num_splits * batch_size
         extra_items = data_items[-overflow:]
         try:
-            batches = np.array_split(
-                np.array(self._accessors
-                         [:num_splits * batch_size]), num_splits)
+            batches = np.array_split(np.array(self._accessors[: num_splits * batch_size]), num_splits)
         except ValueError:
-            log(f"There is less data ({len(self._accessors)}) than the provided "
-                f"batch size ({batch_size}). Consider using a smaller batch size.")
+            log(
+                f"There is less data ({len(self._accessors)}) than the provided "
+                f"batch size ({batch_size}). Consider using a smaller batch size."
+            )
             batches = [self._accessors]
         else:
             if len(extra_items) < batch_size:
                 batches.append(extra_items)
-        self._accessors = np.array(batches, dtype = object)
+        self._accessors = np.array(batches, dtype=object)
         self._batch_size = batch_size
 
     def assign_resize(self, image_size, method):
         """Assigns a resizing factor for the image and annotation data."""
         if image_size is None:
-            image_size = 'default'
+            image_size = "default"
         self._resize_manager.assign(image_size, method)
 
     def _warn_training_resize(self):
         """Warn the user if they are not resizing during training."""
-        if self._resize_manager._resize_type == 'default':
-            log(f"Warning: you have not applied any resizing method to the "
+        if self._resize_manager._resize_type == "default":
+            log(
+                f"Warning: you have not applied any resizing method to the "
                 f"dataset `{self._dataset_name}`. This may cause errors during "
-                f"training if the image aspect ratios are not consistent.")
+                f"training if the image aspect ratios are not consistent."
+            )
 
     def push_transforms(self, **transform_dict):
         """Pushes a transformation to the data transform pipeline."""
         # Check if any transforms are being reset and assign them as such.
         if all(i is NoArgument for i in transform_dict):
             transform_dict = {
-                'transform': 'reset',
-                'target_transform': 'reset',
-                'dual_transform': 'reset'
+                "transform": "reset",
+                "target_transform": "reset",
+                "dual_transform": "reset",
             }
         else:
             empty_keys, reset_keys = [], []
@@ -251,24 +256,22 @@ def push_transforms(self, **transform_dict):
             if len(empty_keys) != 0:
                 for key, value in transform_dict.items():
                     if value is None:
-                        transform_dict[key] = 'reset'
+                        transform_dict[key] = "reset"
                     elif value is NoArgument:
                         transform_dict[key] = None
 
         # There is no `dual_transform` object for image classification.
-        if self._task == 'image_classification':
-            if transform_dict['dual_transform'] is None:
-                transform_dict['dual_transform'] = 'reset'
+        if self._task == "image_classification":
+            if transform_dict["dual_transform"] is None:
+                transform_dict["dual_transform"] = "reset"
 
         # Assign the transforms to the manager in order.
-        for key in ['transform', 'target_transform', 'dual_transform']:
+        for key in ["transform", "target_transform", "dual_transform"]:
             self._transform_manager.assign(key, transform_dict[key])
 
     def _load_one_image_and_annotation(self, obj):
         """Loads one image and annotation from a `DataObject`."""
-        return self._train_manager.apply(
-            obj = obj, batch_state = self._batch_size is not None
-        )
+        return self._train_manager.apply(obj=obj, batch_state=self._batch_size is not None)
 
     def _load_multiple_items(self, indexes):
         """Loads multiple images and annotations from a set of `DataObject`s."""
@@ -279,8 +282,7 @@ def _load_multiple_items(self, indexes):
                 contents.append(self._load_batch(self._accessors[i]))
         else:
             for i in indexes:
-                contents.append(self._load_one_image_and_annotation(
-                    self._data_objects[self._accessors[i]]))
+                contents.append(self._load_one_image_and_annotation(self._data_objects[self._accessors[i]]))
         return contents
 
     def _batch_multi_image_inputs(self, images):
@@ -300,17 +302,19 @@ def _batch_multi_image_inputs(self, images):
     def _batch_multi_output_annotations(self, annotations):
         """Converts either a list of annotations or multiple annotation types into a batch."""
         # If the output annotations are simple objects.
-        if (isinstance(annotations[0], (list, np.ndarray))
+        if (
+            isinstance(annotations[0], (list, np.ndarray))
             or isinstance(annotations, (list, np.ndarray))
-                and isinstance(annotations[0], (int, float))):
+            and isinstance(annotations[0], (int, float))
+        ):
             if not consistent_shapes(annotations):
-                annotations = np.array(annotations, dtype = object)
+                annotations = np.array(annotations, dtype=object)
             else:
                 annotations = np.array(annotations)
             return annotations
 
         # For object detection, just return the COCO JSON dictionaries.
-        if self._task == 'object_detection':
+        if self._task == "object_detection":
             return annotations
 
         # Otherwise, convert all of them independently.
@@ -331,8 +335,7 @@ def _load_batch(self, batch_indexes):
         # Get the images and annotations from the data objects.
         images, annotations = [], []
         for index in batch_indexes:
-            image, annotation = self._load_one_image_and_annotation(
-                self._data_objects[index])
+            image, annotation = self._load_one_image_and_annotation(self._data_objects[index])
             images.append(image)
             annotations.append(annotation)
 
@@ -346,10 +349,7 @@ def _load_batch(self, batch_indexes):
         annotations = self._batch_multi_output_annotations(annotations)
 
         # Return the batches.
-        return self._train_manager.make_batch(
-            images = images,
-            annotations = annotations
-        )
+        return self._train_manager.make_batch(images=images, annotations=annotations)
 
     def get(self, indexes):
         """Loads and processes a piece (or pieces) of data from the dataset.
@@ -362,9 +362,7 @@ def get(self, indexes):
         # If there is only one index and the data is not batched,
         # then we just need to return a single `DataObject`.
         if isinstance(indexes, int) and self._batch_size is None:
-            return self._load_one_image_and_annotation(
-                self._data_objects[self._accessors[indexes]]
-            )
+            return self._load_one_image_and_annotation(self._data_objects[self._accessors[indexes]])
 
         # If we have a batch of images, then return the batch.
         if isinstance(indexes, int) and self._batch_size is not None:
@@ -374,13 +372,3 @@ def get(self, indexes):
         # slice or just a tuple of integers), then we get multiple images.
         if isinstance(indexes, (list, tuple)):
             return self._load_multiple_items(indexes)
-
-    
-
-
-
-
-
-
-
-
diff --git a/agml/data/managers/resize.py b/agml/data/managers/resize.py
index 277011b3..34c63191 100644
--- a/agml/data/managers/resize.py
+++ b/agml/data/managers/resize.py
@@ -19,10 +19,10 @@
 import numpy as np
 
 from agml.framework import AgMLSerializable
-from agml.utils.logging import log
-from agml.utils.image import imread_context
 from agml.utils.general import resolve_tuple
+from agml.utils.image import imread_context
 from agml.utils.io import recursive_dirname
+from agml.utils.logging import log
 
 
 class ImageResizeManager(AgMLSerializable):
@@ -60,15 +60,22 @@ class ImageResizeManager(AgMLSerializable):
     Note: Images will be resized *before* being passed into
     a transformation pipeline. This is to prevent data loss.
     """
+
     serializable = frozenset(
-        ('task', 'dataset_name', 'dataset_root', 'auto_enabled',
-         'resize_type', 'image_size', 'interpolation'))
+        (
+            "task",
+            "dataset_name",
+            "dataset_root",
+            "auto_enabled",
+            "resize_type",
+            "image_size",
+            "interpolation",
+        )
+    )
 
     # Stores the path to the local file which contains the
     # information on the image shapes in all of the datasets.
-    _shape_info_file = os.path.join(
-        recursive_dirname(__file__, 3),
-        '_assets', 'shape_info.pickle')
+    _shape_info_file = os.path.join(recursive_dirname(__file__, 3), "_assets", "shape_info.pickle")
 
     # Stores the default image size if it is not inferenced.
     _default_size = (512, 512)
@@ -81,7 +88,7 @@ def __init__(self, task, dataset, root):
         self._dataset_name = dataset
         self._dataset_root = root
 
-        self._resize_type = 'default'
+        self._resize_type = "default"
         self._image_size = None
         self._interpolation = cv2.INTER_LINEAR
 
@@ -109,58 +116,59 @@ def _method_resize(self, image, size):
 
     def assign(self, kind, method=None):
         """Assigns the resize parameter (and does necessary calculations)."""
-        if kind == 'default':
-            self._resize_type = 'default'
+        if kind == "default":
+            self._resize_type = "default"
             self._image_size = None
-        elif kind == 'train':
-            self._resize_type = 'train'
+        elif kind == "train":
+            self._resize_type = "train"
             self._image_size = self._default_size
-        elif kind == 'imagenet':
-            self._resize_type = 'imagenet'
+        elif kind == "imagenet":
+            self._resize_type = "imagenet"
             self._image_size = self._imagenet_size
         elif isinstance(kind, (list, tuple, np.ndarray, set)):
             if not len(kind) == 2:
                 raise ValueError(
                     f"Got a sequence {kind}, expected two values for "
-                    f"the height and width but got {len(kind)} values.")
-            self._resize_type = 'custom_size'
+                    f"the height and width but got {len(kind)} values."
+                )
+            self._resize_type = "custom_size"
             self._image_size = tuple([i for i in kind])
-        elif 'auto' in kind:
+        elif "auto" in kind:
             # This means that the dataloader has been exported in some format.
             # First, we check whether a different size has automatically been
             # set, since if it has, we don't want to override that size.
-            if kind == 'train-auto':
+            if kind == "train-auto":
                 if not self._auto_enabled:
-                    self._resize_type = 'train'
+                    self._resize_type = "train"
                     self._image_size = self._default_size
-                elif self._resize_type == 'default':
+                elif self._resize_type == "default":
                     info = self._maybe_load_shape_info()
                     if info is None:
                         shape = self._random_inference_shape()
                     else:
                         shape = self._inference_shape(info)
-                    self._resize_type = 'auto'
+                    self._resize_type = "auto"
                     self._image_size = resolve_tuple(shape)
 
         # Check interpolation method independently.
         if method is not None:
             method = method.lower()
-            if method not in ['bilinear', 'area', 'nearest', 'cubic']:
+            if method not in ["bilinear", "area", "nearest", "cubic"]:
                 raise ValueError(f"Invalid interpolation method: {method}.")
             self._interpolation = {
-                'bilinear': cv2.INTER_LINEAR,
-                'area': cv2.INTER_AREA,
-                'nearest': cv2.INTER_NEAREST,
-                'cubic': cv2.INTER_CUBIC
+                "bilinear": cv2.INTER_LINEAR,
+                "area": cv2.INTER_AREA,
+                "nearest": cv2.INTER_NEAREST,
+                "cubic": cv2.INTER_CUBIC,
             }[method]
 
     def apply(self, contents):
         """Applies the resizing operation to the input data."""
-        if self._task in ['image_classification', 'image_regression']:
+        if self._task in ["image_classification", "image_regression"]:
             return self._resize_image_input(contents, self._image_size)
-        elif self._task == 'object_detection':
+        elif self._task == "object_detection":
             return self._resize_image_and_coco(contents, self._image_size)
-        elif self._task == 'semantic_segmentation':
+        elif self._task == "semantic_segmentation":
             return self._resize_image_and_mask(contents, self._image_size)
 
     def _inference_shape(self, info):
@@ -208,8 +216,10 @@ def _inference_shape(self, info):
             two_pluralities = shapes[np.where(count_proportions >= 0.35)[0]]
             if len(two_pluralities) != 2:
                 return self._get_log_default_shape()
-            outs = (self._tuple_euclidean(two_pluralities[0], self._default_size),
-                    self._tuple_euclidean(two_pluralities[1], self._default_size))
+            outs = (
+                self._tuple_euclidean(two_pluralities[0], self._default_size),
+                self._tuple_euclidean(two_pluralities[1], self._default_size),
+            )
             return two_pluralities[outs.index(max(outs))][0].tolist()
 
         return self._get_log_default_shape()
@@ -224,10 +234,12 @@ def _random_inference_shape(self):
         would do in the regular shape inference method, only with a
         random sample instead of the entire dataset for reference.
         """
-        log(f"Could not find shape information for {self._dataset_name}. "
-            f"Attempting to randomly inference the dataset shape.")
+        log(
+            f"Could not find shape information for {self._dataset_name}. "
+            f"Attempting to randomly inference the dataset shape."
+        )
 
-        image_path = os.path.join(self._dataset_root, 'images')
+        image_path = os.path.join(self._dataset_root, "images")
         images = np.random.choice(os.listdir(image_path), size=25)
 
         # Get all of the shapes from the random sample of images.
@@ -245,21 +257,24 @@ def _random_inference_shape(self):
     def _maybe_load_shape_info(self):
         """Loads the contents of the shape information file."""
         try:
-            with open(self._shape_info_file, 'rb') as f:
+            with open(self._shape_info_file, "rb") as f:
                 contents = pickle.load(f)
                 return contents.get(self._dataset_name, None)
         except OSError:
             raise EnvironmentError(
                 f"Could not find the local file {self._shape_info_file} "
                 f"containing shape information. There was likely a problem "
-                f"when building AgML. Please re-install it.")
+                f"when building AgML. Please re-install it."
+            )
 
     def _get_log_default_shape(self):
         """Returns the default shape and warns that no shape could be inferenced."""
-        log(f"No specific shape could be inferenced for the dataset "
+        log(
+            f"No specific shape could be inferenced for the dataset "
             f"{self._dataset_name}. Using the default shape of (512, "
             f"512). Please use this instead of 'auto'. You can set this "
-            f"shape by default by using the parameter 'train'.")
+            f"shape by default by using the parameter 'train'."
+        )
         return self._default_size
 
     # The following methods conduct the actual resizing of the images
@@ -272,8 +287,8 @@ def _resize_image_input(self, contents, image_size):
             return self._resize_single_image(contents, image_size)
         if image_size is not None:
             return {
-                k: self._method_resize(i.astype(np.uint16), image_size).astype(np.int32)
-                for k, i in image.items()}, label
+                k: self._method_resize(i.astype(np.uint16), image_size).astype(np.int32) for k, i in image.items()
+            }, label
         return image, label
 
     def _resize_single_image(self, contents, image_size):
@@ -288,13 +303,11 @@ def _resize_image_and_coco(self, contents, image_size):
         if image_size is not None:
             # Extract the original size of the bounding boxes.
             y_scale, x_scale = image.shape[0:2]
-            bboxes = coco['bbox']
+            bboxes = coco["bbox"]
             processed_bboxes = []
             for bbox in bboxes:
                 x1, y1, width, height = bbox
-                processed_bboxes.append([
-                    x1 / x_scale, y1 / y_scale,
-                    width / x_scale, height / y_scale])
+                processed_bboxes.append([x1 / x_scale, y1 / y_scale, width / x_scale, height / y_scale])
 
             # Clip the bounding boxes (There might be a case where
             # the bounding box is on the edge, but goes to just over 1.0
@@ -311,15 +324,17 @@ def _resize_image_and_coco(self, contents, image_size):
             for bbox in processed_bboxes:
                 x1, y1, width, height = bbox
                 new_bbox = [
-                    int(x1 * x_new), int(y1 * y_new),
-                    int(width * x_new), int(height * y_new)]
+                    int(x1 * x_new),
+                    int(y1 * y_new),
+                    int(width * x_new),
+                    int(height * y_new),
+                ]
                 final_processed_bboxes.append(new_bbox)
                 areas.append(new_bbox[2] * new_bbox[3])
-            final_processed_bboxes = \
-                np.array(final_processed_bboxes).astype(np.int32)
-            coco['bbox'] = final_processed_bboxes
+            final_processed_bboxes = np.array(final_processed_bboxes).astype(np.int32)
+            coco["bbox"] = final_processed_bboxes
             areas = np.array(areas).astype(np.int32)
-            coco['area'] = areas
+            coco["area"] = areas
         return image, coco
 
     def _resize_image_and_mask(self, contents, image_size):
@@ -329,9 +344,3 @@ def _resize_image_and_mask(self, contents, image_size):
             image = self._method_resize(image, image_size)
             mask = cv2.resize(mask, image_size, cv2.INTER_NEAREST)
         return image, mask
-
-
-
-
-
-
diff --git a/agml/data/managers/training.py b/agml/data/managers/training.py
index ecf7034a..4563bfe4 100644
--- a/agml/data/managers/training.py
+++ b/agml/data/managers/training.py
@@ -16,22 +16,27 @@
 
 import numpy as np
 
-from agml.framework import AgMLSerializable
-from agml.utils.image import needs_batch_dim
 from agml.backend.tftorch import (
-    tf, torch, set_backend, get_backend,
-    user_changed_backend, StrictBackendError,
-    _convert_image_to_torch, is_array_like
+    StrictBackendError,
+    _convert_image_to_torch,
+    get_backend,
+    is_array_like,
+    set_backend,
+    tf,
+    torch,
+    user_changed_backend,
 )
+from agml.framework import AgMLSerializable
+from agml.utils.image import needs_batch_dim
 
 
 class TrainState(Enum):
     NONE = None
-    TF = 'tf'
-    TORCH = 'torch'
-    EVAL = 'eval'
-    EVAL_TF = 'eval-tf'
-    EVAL_TORCH = 'eval-torch'
+    TF = "tf"
+    TORCH = "torch"
+    EVAL = "eval"
+    EVAL_TF = "eval-tf"
+    EVAL_TORCH = "eval-torch"
     FALSE = False
 
 
@@ -54,11 +59,10 @@ class TrainingManager(AgMLSerializable):
     as well as being able to manage whether certain preprocessing steps
     should be applied, allowing for independent train and eval modes.
     """
-    serializable = frozenset((
-        'transform_manager', 'resize_manager',
-        'state', 'task', 'remap_hook', 'name'))
 
-    def __init__(self, transform_manager, resize_manager, task = None):
+    serializable = frozenset(("transform_manager", "resize_manager", "state", "task", "remap_hook", "name"))
+
+    def __init__(self, transform_manager, resize_manager, task=None):
         # Update the general parameters for the loader.
         self._task = task
         self._name = resize_manager._dataset_name
@@ -149,18 +153,18 @@ def update_state(self, state):
         # Apply a 'tf' or 'torch' backend conversion.
         elif t_(state) == TrainState.TORCH:
             self._state = TrainState.TORCH
-            if get_backend() == 'tf':
+            if get_backend() == "tf":
                 if user_changed_backend():
-                    raise StrictBackendError(change = 'torch', obj = t_(state))
-                set_backend('torch')
-            self._resize_manager.assign('train-auto')
+                    raise StrictBackendError(change="torch", obj=t_(state))
+                set_backend("torch")
+            self._resize_manager.assign("train-auto")
         elif t_(state) == TrainState.TF:
             self._state = TrainState.TF
-            if get_backend() == 'torch':
+            if get_backend() == "torch":
                 if user_changed_backend():
-                    raise StrictBackendError(change = 'tf', obj = t_(state))
-                set_backend('tf')
-            self._resize_manager.assign('train-auto')
+                    raise StrictBackendError(change="tf", obj=t_(state))
+                set_backend("tf")
+            self._resize_manager.assign("train-auto")
 
         # Set the default conversion (`None`).
         elif t_(state) == TrainState.NONE:
@@ -189,7 +193,7 @@ def apply(self, obj, batch_state):
         # If there is a hook to apply (for multi-dataset loaders),
         # then apply the hook before doing anything else.
         if self._remap_hook:
-            contents = self._remap_hook(contents, self._name) # noqa
+            contents = self._remap_hook(contents, self._name)  # noqa
 
         # If the state is set to `False`, then just return the raw contents.
         if self._state is TrainState.FALSE:
@@ -200,9 +204,11 @@ def apply(self, obj, batch_state):
 
         # If we are in a training state or `None`, (so not an evaluation
         # state or `False`), then we apply the transforms to the images.
-        if self._state not in [TrainState.EVAL,
-                               TrainState.EVAL_TF,
-                               TrainState.EVAL_TORCH]:
+        if self._state not in [
+            TrainState.EVAL,
+            TrainState.EVAL_TF,
+            TrainState.EVAL_TORCH,
+        ]:
             contents = self._transform_manager.apply(contents)
 
         # If the images are not in a batch, then we convert them to tensors
@@ -228,11 +234,9 @@ def make_batch(self, images, annotations):
         if self._state in [TrainState.NONE, TrainState.FALSE, TrainState.EVAL]:
             return images, annotations
         elif self._state in [TrainState.TF, TrainState.EVAL_TF]:
-            return self._tf_tensor_batch_convert(
-                (images, annotations), self._task)
+            return self._tf_tensor_batch_convert((images, annotations), self._task)
         elif self._state in [TrainState.TORCH, TrainState.EVAL_TORCH]:
-            return self._torch_tensor_batch_convert(
-                (images, annotations), self._task)
+            return self._torch_tensor_batch_convert((images, annotations), self._task)
         return images, annotations
 
     @staticmethod
@@ -255,26 +259,27 @@ def _tf_tensor_convert(contents, task):
         # Convert the image and annotation to `tf.Tensor`s.
         image, annotation = contents
         image = TrainingManager._tf_tensor_image_convert(image)
-        if task in ['image_classification',
-                    'image_regression',
-                    'semantic_segmentation']:
+        if task in [
+            "image_classification",
+            "image_regression",
+            "semantic_segmentation",
+        ]:
             if isinstance(annotation, (int, np.ndarray)):
                 annotation = tf.constant(annotation)
             else:
                 for k, v in annotation.items():
                     annotation[k] = tf.constant(v)
-        elif task == 'object_detection':
-            annotation = TrainingManager._tf_tensor_coco_convert(
-                annotation)
+        elif task == "object_detection":
+            annotation = TrainingManager._tf_tensor_coco_convert(annotation)
 
         # Add a first-dimension batch to the image.
         if isinstance(image, tf.Tensor):
             if needs_batch_dim(image):
-                image = tf.expand_dims(image, axis = 0)
+                image = tf.expand_dims(image, axis=0)
         else:
             for k, v in image.items():
                 if needs_batch_dim(v):
-                    image[k] = tf.expand_dims(v, axis = 0)
+                    image[k] = tf.expand_dims(v, axis=0)
         return image, annotation
 
     @staticmethod
@@ -283,19 +288,18 @@ def _tf_tensor_batch_convert(contents, task):
         # This stacks the images and annotations together.
         images, annotations = contents
         images = TrainingManager._tf_tensor_image_batch_convert(images)
-        if task == 'image_classification':
+        if task == "image_classification":
             annotations = tf.constant(annotations)
-        elif task == 'image_regression':
+        elif task == "image_regression":
             if isinstance(annotations, np.ndarray):
                 annotations = tf.constant(annotations)
             else:
                 for k, v in annotations.items():
                     annotations[k] = tf.constant(v)
-        elif task == 'semantic_segmentation':
-            annotations = tf.stack(annotations, axis = 0)
-        elif task == 'object_detection':
-            annotations = [TrainingManager._tf_tensor_coco_convert(
-                a_set) for a_set in annotations]
+        elif task == "semantic_segmentation":
+            annotations = tf.stack(annotations, axis=0)
+        elif task == "object_detection":
+            annotations = [TrainingManager._tf_tensor_coco_convert(a_set) for a_set in annotations]
         return images, annotations
 
     @staticmethod
@@ -317,28 +321,24 @@ def _torch_tensor_image_convert(image):
     def _torch_tensor_image_batch_convert(batch):
         """Converts potential multi-image input batch dicts to tensor dicts."""
         if is_array_like(batch):
-            return torch.stack([
-                _convert_image_to_torch(image) for image in batch])
-        return {k: TrainingManager.
-            _torch_tensor_image_batch_convert(b) for k, b in batch.items()}
+            return torch.stack([_convert_image_to_torch(image) for image in batch])
+        return {k: TrainingManager._torch_tensor_image_batch_convert(b) for k, b in batch.items()}
 
     @staticmethod
     def _torch_tensor_convert(contents, task):
         """Converts contents to `torch.Tensor`s where possible."""
         image, annotation = contents
         image = TrainingManager._torch_tensor_image_convert(image)
-        if task in ['image_classification',
-                    'image_regression']:
+        if task in ["image_classification", "image_regression"]:
             if isinstance(annotation, (int, np.ndarray)):
                 annotation = torch.tensor(annotation)
             else:
                 for k, v in annotation.items():
                     annotation[k] = torch.tensor(v)
-        elif task == 'semantic_segmentation':
+        elif task == "semantic_segmentation":
             annotation = _convert_image_to_torch(annotation)
-        elif task == 'object_detection':
-            annotation = TrainingManager._torch_tensor_coco_convert(
-                annotation)
+        elif task == "object_detection":
+            annotation = TrainingManager._torch_tensor_coco_convert(annotation)
         return image, annotation
 
     @staticmethod
@@ -346,19 +346,16 @@ def _torch_tensor_batch_convert(contents, task):
         """Converts batch contents to `torch.Tensor`s where possible."""
         images, annotations = contents
         images = TrainingManager._torch_tensor_image_batch_convert(images)
-        if task in ['image_classification',
-                    'image_regression']:
+        if task in ["image_classification", "image_regression"]:
             if isinstance(annotations, (int, np.ndarray)):
                 annotations = torch.tensor(annotations)
             else:
                 for k, v in annotations.items():
                     annotations[k] = torch.tensor(v)
-        elif task == 'semantic_segmentation':
-            annotations = torch.stack([
-                _convert_image_to_torch(a) for a in annotations])
-        elif task == 'object_detection':
-            annotations = [TrainingManager._torch_tensor_coco_convert(
-                a_set) for a_set in annotations]
+        elif task == "semantic_segmentation":
+            annotations = torch.stack([_convert_image_to_torch(a) for a in annotations])
+        elif task == "object_detection":
+            annotations = [TrainingManager._torch_tensor_coco_convert(a_set) for a_set in annotations]
         return images, annotations
 
     @staticmethod
@@ -366,16 +363,10 @@ def _torch_tensor_coco_convert(contents):
         """Converts a COCO JSON dictionary to a `torch.Tensor`."""
         coco_tensor = {}
         for key, value in contents.items():
-            if key == 'segmentation':
+            if key == "segmentation":
                 value = np.empty(0)
             if not isinstance(value, torch.Tensor):
                 coco_tensor[key] = torch.tensor(value)
             else:
                 coco_tensor[key] = value
         return coco_tensor
-
-
-
-
-
-
diff --git a/agml/data/managers/transform_helpers.py b/agml/data/managers/transform_helpers.py
index 3d9b92a7..5e8f697b 100644
--- a/agml/data/managers/transform_helpers.py
+++ b/agml/data/managers/transform_helpers.py
@@ -31,7 +31,8 @@ class TransformApplierBase(AgMLSerializable):
     require keyword arguments. This wrapper allows them to be used
     as a traditional method for consistency in application.
     """
-    serializable = frozenset(('transform', ))
+
+    serializable = frozenset(("transform",))
 
     def __init__(self, transform):
         self._transform = transform
@@ -50,14 +51,14 @@ def __str__(self):
 
 class AlbumentationsTransformSingle(TransformApplierBase):
     def apply(self, image):
-        transform = self._transform(image = image)
-        return transform['image']
+        transform = self._transform(image=image)
+        return transform["image"]
 
 
 class AlbumentationsTransformMask(TransformApplierBase):
     def apply(self, image, mask):
-        transform = self._transform(image = image, mask = mask)
-        return transform['image'], transform['mask']
+        transform = self._transform(image=image, mask=mask)
+        return transform["image"], transform["mask"]
 
 
 class AlbumentationsTransformCOCO(TransformApplierBase):
@@ -66,17 +67,15 @@ def apply(self, image, coco):
         # to the COCO JSON dictionary as we need to extract the
         # bounding boxes/category IDs, do the transformation on those,
         # and then re-insert them into the COCO dictionary.
-        coco_boxes = coco['bbox']
-        coco_labels = coco['category_id']
+        coco_boxes = coco["bbox"]
+        coco_labels = coco["category_id"]
         bboxes = np.c_[coco_boxes, coco_labels]
-        transform = self._transform(image = image, bboxes = bboxes)
-        image, bboxes = transform['image'], \
-                        np.array(transform['bboxes'])[:, :-1]
-        coco['bbox'], areas = bboxes, []
+        transform = self._transform(image=image, bboxes=bboxes)
+        image, bboxes = transform["image"], np.array(transform["bboxes"])[:, :-1]
+        coco["bbox"], areas = bboxes, []
         for box in bboxes:
-            areas.append(
-                (box[0] + box[2]) * (box[1] + box[3]))
-        coco['area'] = areas.copy()
+            areas.append((box[0] + box[2]) * (box[1] + box[3]))
+        coco["area"] = areas.copy()
         return image, coco
 
 
@@ -87,7 +86,7 @@ def apply(self, image, mask):
         # it to the image and mask to get the same results for both
         # the image and the mask. So, we change the seed each time, but
         # we also reset the seed so that it goes back to normal afterwards.
-        seed = np.random.randint((1 << 31) - 1) # default is 32-bit systems
+        seed = np.random.randint((1 << 31) - 1)  # default is 32-bit systems
         with seed_context(seed) as context:
             image = self._transform(image)
             context.reset()
@@ -97,6 +96,7 @@ def apply(self, image, mask):
 
 class NormalizationTransformBase(TransformApplierBase, abc.ABC):
     """A subclass to mark transforms as normalizing transforms."""
+
     pass
 
 
@@ -115,9 +115,9 @@ def apply(self, image):
             image = (image / 255).astype(np.float32)
 
         mean, std = self._transform
-        mean = np.array(mean, dtype = np.float32)
-        std = np.array(std, dtype = np.float32)
-        denominator = np.reciprocal(std, dtype = np.float32)
+        mean = np.array(mean, dtype=np.float32)
+        std = np.array(std, dtype=np.float32)
+        denominator = np.reciprocal(std, dtype=np.float32)
         image = (image - mean) * denominator
         return image
 
@@ -126,7 +126,7 @@ class OneHotLabelTransform(TransformApplierBase):
     def apply(self, labels):
         # This applies a one-hot label transformation. The only argument
         # in the `_transform` parameter is simply the number of labels.
-        one_hot = np.zeros(shape = (self._transform, ))
+        one_hot = np.zeros(shape=(self._transform,))
         one_hot[labels] = 1
         return one_hot.astype(np.float32)
 
@@ -138,8 +138,8 @@ def apply(self, mask):
         input_shape = mask.shape
         mask = mask.ravel()
         n = mask.shape[0]
-        mask = np.array(mask, dtype = np.int32)
-        out = np.zeros(shape = (n, self._transform + 1))
+        mask = np.array(mask, dtype=np.int32)
+        out = np.zeros(shape=(n, self._transform + 1))
         out[np.arange(n), mask] = 1
         out = np.reshape(out, input_shape + (self._transform + 1,))
         return out[..., 1:].astype(np.int32)
@@ -154,8 +154,6 @@ def apply(self, image, mask):
             image = image[:, :, None]
         image = torch.from_numpy(image).permute(2, 0, 1).contiguous()
         if isinstance(image, torch.ByteTensor):
-            image = image.to(dtype = torch.float32).div(255)
+            image = image.to(dtype=torch.float32).div(255)
         mask = torch.from_numpy(mask)
         return mask
-
-
diff --git a/agml/data/managers/transforms.py b/agml/data/managers/transforms.py
index 677a4b49..3fcd0b56 100644
--- a/agml/data/managers/transforms.py
+++ b/agml/data/managers/transforms.py
@@ -12,34 +12,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import types
-import inspect
 import functools
+import inspect
+import types
 from enum import Enum
 
-from agml.framework import AgMLSerializable
-from agml.backend.tftorch import (
-    get_backend, set_backend, user_changed_backend, StrictBackendError
-)
+from agml.backend.tftorch import StrictBackendError, get_backend, set_backend, user_changed_backend
 from agml.data.managers.transform_helpers import (
-    AlbumentationsTransformSingle,
-    AlbumentationsTransformMask,
     AlbumentationsTransformCOCO,
-    SameStateImageMaskTransform,
-    NormalizationTransformBase,
-    ScaleTransform,
+    AlbumentationsTransformMask,
+    AlbumentationsTransformSingle,
+    MaskToChannelBasisTransform,
     NormalizationTransform,
+    NormalizationTransformBase,
     OneHotLabelTransform,
-    MaskToChannelBasisTransform,
-    ToTensorSeg
+    SameStateImageMaskTransform,
+    ScaleTransform,
+    ToTensorSeg,
 )
+from agml.framework import AgMLSerializable
 from agml.utils.logging import log
 
 
 class TransformKind(Enum):
-    Transform = 'transform'
-    TargetTransform = 'target_transform'
-    DualTransform = 'dual_transform'
+    Transform = "transform"
+    TargetTransform = "target_transform"
+    DualTransform = "dual_transform"
 
 
 # Shorthand form of the enum for testing explicit values.
@@ -67,9 +65,16 @@ class TransformManager(AgMLSerializable):
     semantic segmentation and object detection transformations, but
     there is no `dual_transform` for image classification.
     """
+
     serializable = frozenset(
-        ('task', 'transforms', 'time_inserted_transforms',
-         'contains_tf_transforms', 'contains_torch_transforms'))
+        (
+            "task",
+            "transforms",
+            "time_inserted_transforms",
+            "contains_tf_transforms",
+            "contains_torch_transforms",
+        )
+    )
 
     def __init__(self, task):
         self._task = task
@@ -116,7 +121,7 @@ def _pop_transform(self, t_type, search_param):
     def assign(self, kind, transform):
         """Assigns a new transform to the manager."""
         # Determine if the transform is being reset or unchanged.
-        if transform == 'reset':
+        if transform == "reset":
             self._transforms.pop(kind, None)
             new_time_transforms = []
             for tfm in self._time_inserted_transforms:
@@ -130,21 +135,22 @@ def assign(self, kind, transform):
 
         # If an `albumentations` transform is passed to the `transform`
         # argument, then it is checked first to see if it is potentially
-        # just processing the input image, and then passed as just a 
+        # just processing the input image, and then passed as just a
         # `transform` (or else it will clash in object detection tasks).
         # Otherwise, it is stored internally as a `dual_transform`.
         if transform is not None:
             try:
-                if 'albumentations' in transform.__module__:
+                if "albumentations" in transform.__module__:
                     if t_(kind) == TransformKind.Transform:
                         if len(transform.processors) != 0:
-                            kind = 'dual_transform'
-                    if self._task == 'semantic_segmentation':
-                        kind = 'dual_transform'
-                elif 'agml.models' in transform.__module__:
+                            kind = "dual_transform"
+                    if self._task == "semantic_segmentation":
+                        kind = "dual_transform"
+                elif "agml.models" in transform.__module__:
                     from agml.models.preprocessing import EfficientDetPreprocessor
+
                     if isinstance(transform, EfficientDetPreprocessor):
-                        kind = 'dual_transform'
+                        kind = "dual_transform"
             except AttributeError:
                 # Some type of object that doesn't have `__module__`.
                 pass
@@ -154,38 +160,40 @@ def assign(self, kind, transform):
         prev = self._transforms.get(kind, None)
 
         # Validate the transformation based on the task and kind.
-        if self._task == 'image_classification':
+        if self._task == "image_classification":
             if t_(kind) == TransformKind.Transform:
                 transform = self._maybe_normalization_or_regular_transform(transform)
             elif t_(kind) == TransformKind.TargetTransform:
                 if isinstance(transform, tuple):  # a special convenience case
-                    if transform[0] == 'one_hot':
+                    if transform[0] == "one_hot":
                         if transform[2] is not True:  # removing the transform
                             self._pop_transform(OneHotLabelTransform, kind)
                             return
                         transform = OneHotLabelTransform(transform[1])
             else:
-                raise ValueError("There is no `dual_transform` for image "
-                                 "classification tasks. Please pass the "
-                                 "input as a `transform` or `target_transform`.")
-        elif self._task == 'image_regression':
+                raise ValueError(
+                    "There is no `dual_transform` for image "
+                    "classification tasks. Please pass the "
+                    "input as a `transform` or `target_transform`."
+                )
+        elif self._task == "image_regression":
             if t_(kind) == TransformKind.Transform:
                 transform = self._maybe_normalization_or_regular_transform(transform)
             elif t_(kind) == TransformKind.TargetTransform:
                 if isinstance(transform, tuple):  # a special convenience case
-                    if transform[0] == 'one_hot':
+                    if transform[0] == "one_hot":
                         if transform[2] is not True:  # removing the transform
                             self._pop_transform(OneHotLabelTransform, kind)
                             return
                         transform = OneHotLabelTransform(transform[1])
             else:
                 pass
-        elif self._task == 'semantic_segmentation':
+        elif self._task == "semantic_segmentation":
             if t_(kind) == TransformKind.Transform:
                 transform = self._maybe_normalization_or_regular_transform(transform)
             elif t_(kind) == TransformKind.TargetTransform:
                 if isinstance(transform, tuple):  # a special convenience case
-                    if transform[0] == 'channel_basis':
+                    if transform[0] == "channel_basis":
                         if transform[2] is not True:  # removing the transform
                             self._pop_transform(MaskToChannelBasisTransform, kind)
                         transform = MaskToChannelBasisTransform(transform[1])
@@ -193,7 +201,7 @@ def assign(self, kind, transform):
                     transform = self._maybe_normalization_or_regular_transform(transform)
             else:
                 transform = self._construct_image_and_mask_transform(transform)
-        elif self._task == 'object_detection':
+        elif self._task == "object_detection":
             if t_(kind) == TransformKind.Transform:
                 transform = self._maybe_normalization_or_regular_transform(transform)
             elif t_(kind) == TransformKind.TargetTransform:
@@ -236,16 +244,13 @@ def apply(self, contents):
         image, annotation = contents
 
         # Iterate through the different transforms.
-        for (kind, transform) in self._time_inserted_transforms:
+        for kind, transform in self._time_inserted_transforms:
             if t_(kind) == TransformKind.Transform:
-                image = self._apply_to_objects(
-                    transform, (image, ), kind)
+                image = self._apply_to_objects(transform, (image,), kind)
             if t_(kind) == TransformKind.TargetTransform:
-                annotation = self._apply_to_objects(
-                    transform, (annotation, ), kind)
+                annotation = self._apply_to_objects(transform, (annotation,), kind)
             if t_(kind) == TransformKind.DualTransform:
-                image, annotation = self._apply_to_objects(
-                    transform, (image, annotation), kind)
+                image, annotation = self._apply_to_objects(transform, (image, annotation), kind)
 
         # Return the processed image and annotation.
         return image, annotation
@@ -256,17 +261,21 @@ def _apply_to_objects(transform, contents, kind):
         try:
             return transform(*contents)
         except Exception as e:
-            default_msg = (f"Encountered an error when attempting to apply "
-                           f"a transform ({transform}) of kind '{kind}' to "
-                           f"objects: {contents}. See the above traceback.")
+            default_msg = (
+                f"Encountered an error when attempting to apply "
+                f"a transform ({transform}) of kind '{kind}' to "
+                f"objects: {contents}. See the above traceback."
+            )
 
             # A specific case of exception where the image first needs
             # to be converted to a PIL image before being used in a
             # general `torchvision.transforms` pipeline.
             if "PIL" in str(e):
-                raise TypeError("If using a `torchvision.transforms` pipeline "
-                                "when not in PyTorch training mode, you need "
-                                "to include `ToTensor()` in the pipeline.")
+                raise TypeError(
+                    "If using a `torchvision.transforms` pipeline "
+                    "when not in PyTorch training mode, you need "
+                    "to include `ToTensor()` in the pipeline."
+                )
 
             # Otherwise, raise the default exception.
             raise Exception(default_msg)
@@ -274,7 +283,7 @@ def _apply_to_objects(transform, contents, kind):
     def _maybe_normalization_or_regular_transform(self, transform):
         """Dispatches to the correct single-image transform construction."""
         if isinstance(transform, tuple):
-            if transform[0] == 'normalize':
+            if transform[0] == "normalize":
                 return self._build_normalization_transform(transform)
         return self._construct_single_image_transform(transform)
 
@@ -290,7 +299,7 @@ def _build_normalization_transform(self, transform):
         # within the transform dict, and then we get its location.
         norm_transform_index, norm_transform_index_time = -1, -1
         try:
-            for i, t in enumerate(self._transforms['transform']):
+            for i, t in enumerate(self._transforms["transform"]):
                 if isinstance(t, NormalizationTransformBase):
                     norm_transform_index = i
                     break
@@ -299,18 +308,20 @@ def _build_normalization_transform(self, transform):
                     norm_transform_index_time = i
                     break
         except:
-            self._transforms['transform'] = []
+            self._transforms["transform"] = []
 
-        if transform[1] == 'scale':
+        if transform[1] == "scale":
             tfm = ScaleTransform(None)
             if norm_transform_index != -1:
-                self._transforms['transform'][norm_transform_index] = tfm
-                self._time_inserted_transforms[norm_transform_index_time] \
-                    = ('transform', tfm)
+                self._transforms["transform"][norm_transform_index] = tfm
+                self._time_inserted_transforms[norm_transform_index_time] = (
+                    "transform",
+                    tfm,
+                )
             else:
-                self._transforms['transform'].append(tfm)
-                self._time_inserted_transforms.append(('transform', tfm))
-        elif hasattr(transform[1], 'mean') or transform[1] == 'imagenet':
+                self._transforms["transform"].append(tfm)
+                self._time_inserted_transforms.append(("transform", tfm))
+        elif hasattr(transform[1], "mean") or transform[1] == "imagenet":
             try:
                 mean, std = transform[1].mean, transform[1].std
             except AttributeError:
@@ -319,38 +330,44 @@ def _build_normalization_transform(self, transform):
                 std = [0.229, 0.224, 0.225]
             tfm = NormalizationTransform((mean, std))
             if norm_transform_index != -1:
-                self._transforms['transform'][norm_transform_index] = tfm
-                self._time_inserted_transforms[norm_transform_index_time] \
-                    = ('transform', tfm)
+                self._transforms["transform"][norm_transform_index] = tfm
+                self._time_inserted_transforms[norm_transform_index_time] = (
+                    "transform",
+                    tfm,
+                )
             else:
-                self._transforms['transform'].append(tfm)
-                self._time_inserted_transforms.append(('transform', tfm))
-        elif transform[1] == 'reset':
+                self._transforms["transform"].append(tfm)
+                self._time_inserted_transforms.append(("transform", tfm))
+        elif transform[1] == "reset":
             if norm_transform_index != -1:
-                self._transforms['transform'].pop(norm_transform_index)
+                self._transforms["transform"].pop(norm_transform_index)
                 self._time_inserted_transforms.pop(norm_transform_index_time)
         return None
 
     def _transform_update_and_check(self, tfm_type):
         """Checks whether a TensorFlow/PyTorch transform has been added."""
         # Check for transform conflicts.
-        if tfm_type == 'torch' and self._contains_tf_transforms:
-            raise TypeError("Received a PyTorch-type transform, yet the loader "
-                            "already contains TensorFlow/Keras transforms. This "
-                            "will cause an error, please only pass one format. If "
-                            "you want to remove a transform, pass a value of `None` "
-                            "to reset all of the transforms for a certain type.")
-        if tfm_type == 'tf' and self._contains_torch_transforms:
-            raise TypeError("Received a TensorFlow/Keras-type transform, yet the "
-                            "loader already contains PyTorch transforms. This "
-                            "will cause an error, please only pass one format. If "
-                            "you want to remove a transform, pass a value of `None` "
-                            "to reset all of the transforms for a certain type.")
+        if tfm_type == "torch" and self._contains_tf_transforms:
+            raise TypeError(
+                "Received a PyTorch-type transform, yet the loader "
+                "already contains TensorFlow/Keras transforms. This "
+                "will cause an error, please only pass one format. If "
+                "you want to remove a transform, pass a value of `None` "
+                "to reset all of the transforms for a certain type."
+            )
+        if tfm_type == "tf" and self._contains_torch_transforms:
+            raise TypeError(
+                "Received a TensorFlow/Keras-type transform, yet the "
+                "loader already contains PyTorch transforms. This "
+                "will cause an error, please only pass one format. If "
+                "you want to remove a transform, pass a value of `None` "
+                "to reset all of the transforms for a certain type."
+            )
 
         # Update the transform type.
-        if tfm_type == 'torch':
+        if tfm_type == "torch":
             self._contains_torch_transforms = True
-        if tfm_type == 'tf':
+        if tfm_type == "tf":
             self._contains_tf_transforms = True
 
     # The following methods implement different checks which validate
@@ -376,35 +393,37 @@ def _construct_single_image_transform(self, transform):
         elif isinstance(transform, (types.FunctionType, functools.partial)):
             sig = inspect.signature(transform).parameters
             if not len(sig) == 1:
-                raise TypeError("Expected a single-image transform passed "
-                                "to `transform` to accept one input image, "
-                                f"instead got {len(sig)} parameters.")
+                raise TypeError(
+                    "Expected a single-image transform passed "
+                    "to `transform` to accept one input image, "
+                    f"instead got {len(sig)} parameters."
+                )
             return transform
 
         # An `albumentations` transform to be applied to the image. This
         # wraps the transform into a method which treats it as a regular
         # functional transform, e.g. no keyword arguments (for easy use).
-        elif 'albumentations' in transform.__module__:
+        elif "albumentations" in transform.__module__:
             return AlbumentationsTransformSingle(transform)
 
         # A set of `torchvision` transforms wrapped into a `T.Compose` object
         # or just a single transformation. This simply confirms the backend.
-        elif 'torchvision' in transform.__module__:
-            if get_backend() != 'torch':
+        elif "torchvision" in transform.__module__:
+            if get_backend() != "torch":
                 if user_changed_backend():
-                    raise StrictBackendError(change = 'tf', obj = transform)
-                set_backend('torch')
-            self._transform_update_and_check('torch')
+                    raise StrictBackendError(change="tf", obj=transform)
+                set_backend("torch")
+            self._transform_update_and_check("torch")
             return transform
 
         # A `tf.keras.Sequential` preprocessing model or an individual
         # Keras preprocessing layer. This simply confirms the backend.
-        elif 'keras' in transform.__module__ or 'tensorflow' in transform.__module__:
-            if get_backend() != 'tf':
+        elif "keras" in transform.__module__ or "tensorflow" in transform.__module__:
+            if get_backend() != "tf":
                 if user_changed_backend():
-                    raise StrictBackendError(change = 'torch', obj = transform)
-                set_backend('tf')
-            self._transform_update_and_check('tf')
+                    raise StrictBackendError(change="torch", obj=transform)
+                set_backend("tf")
+            self._transform_update_and_check("tf")
             return transform
 
         # Otherwise, it may be a transform from a (lesser-known) third-party
@@ -437,16 +456,18 @@ def _construct_image_and_mask_transform(self, transform):
         elif isinstance(transform, (types.FunctionType, functools.partial)):
             sig = inspect.signature(transform).parameters
             if not len(sig) == 2:
-                raise TypeError(f"Expected a semantic segmentation transform "
-                                f"passed to `transform` to accept two args: "
-                                f"an input image and an annotation mask, "
-                                f"instead got {len(sig)} parameters.")
+                raise TypeError(
+                    f"Expected a semantic segmentation transform "
+                    f"passed to `transform` to accept two args: "
+                    f"an input image and an annotation mask, "
+                    f"instead got {len(sig)} parameters."
+                )
             return transform
 
         # An `albumentations` transform to be applied to the image. This
         # wraps the transform into a method which treats it as a regular
         # functional transform, e.g. no keyword arguments (for easy use).
-        elif 'albumentations' in transform.__module__:
+        elif "albumentations" in transform.__module__:
             return AlbumentationsTransformMask(transform)
 
         # If we have the case of a transform that needs to be applied to
@@ -455,46 +476,52 @@ def _construct_image_and_mask_transform(self, transform):
         # when the signature of the input function accepts only one input
         # parameter or it belongs to `torchvision` transform (not Keras).
         if len(inspect.signature(transform).parameters) == 1:
-            if 'torchvision' in transform.__module__:
-                if get_backend() != 'torch':
+            if "torchvision" in transform.__module__:
+                if get_backend() != "torch":
                     if user_changed_backend():
-                        raise StrictBackendError(
-                            change = 'tf', obj = transform)
-                    set_backend('torch')
+                        raise StrictBackendError(change="tf", obj=transform)
+                    set_backend("torch")
 
                 # Update `torchvision.transforms.ToTensor` to a custom
                 # updated class as this will modify the mask incorrectly.
                 import torchvision
+
                 if isinstance(transform, torchvision.transforms.ToTensor):
                     transform = ToTensorSeg(None)
-                    log("Updated `ToTensor` transform in the provided pipeline "
+                    log(
+                        "Updated `ToTensor` transform in the provided pipeline "
                         f"{transform} to an updated transform which does not "
                         f"modify the mask. If you want to change this behaviour, "
-                        f"please raise an error with the AgML team.")
+                        f"please raise an error with the AgML team."
+                    )
                 elif isinstance(transform, torchvision.transforms.Compose):
                     tfm_list = transform.transforms.copy()
                     for i, compose_tfm in enumerate(transform.transforms):
                         if isinstance(compose_tfm, torchvision.transforms.ToTensor):
                             tfm_list[i] = ToTensorSeg(None)
                     transform = torchvision.transforms.Compose(tfm_list)
-                    log("Updated `ToTensor` transform in the provided pipeline "
+                    log(
+                        "Updated `ToTensor` transform in the provided pipeline "
                         f"{transform} to an updated transform which does not "
                         f"modify the mask. If you want to change this behaviour, "
-                        f"please raise an error with the AgML team.")
+                        f"please raise an error with the AgML team."
+                    )
 
-                self._transform_update_and_check('torch')
-            elif 'keras.layers' in transform.__module__:
-                if get_backend() != 'tf':
+                self._transform_update_and_check("torch")
+            elif "keras.layers" in transform.__module__:
+                if get_backend() != "tf":
                     if user_changed_backend():
-                        raise StrictBackendError(
-                            change = 'torch', obj = transform)
-                    set_backend('tf')
-                log('Got a Keras transformation for a dual image and '
-                    'mask transform. If you are passing preprocessing '
-                    'layers to this method, then use `agml.data.experimental'
-                    '.generate_keras_segmentation_dual_transform` in order '
-                    'for the random state to be applied properly.', 'warning')
-                self._transform_update_and_check('tf')
+                        raise StrictBackendError(change="torch", obj=transform)
+                    set_backend("tf")
+                log(
+                    "Got a Keras transformation for a dual image and "
+                    "mask transform. If you are passing preprocessing "
+                    "layers to this method, then use `agml.data.experimental"
+                    ".generate_keras_segmentation_dual_transform` in order "
+                    "for the random state to be applied properly.",
+                    "warning",
+                )
+                self._transform_update_and_check("tf")
             return SameStateImageMaskTransform(transform)
 
         # Another type of transform, most likely some form of transform
@@ -521,21 +548,21 @@ def _construct_image_and_coco_transform(transform):
         elif isinstance(transform, (types.FunctionType, functools.partial)):
             sig = inspect.signature(transform).parameters
             if not len(sig) == 2:
-                raise TypeError(f"Expected a object detection transform passed "
-                                f"to `transform` to accept two args: an input "
-                                f"image and a COCO JSON dictionary, instead "
-                                f"got {len(sig)} parameters.")
+                raise TypeError(
+                    f"Expected a object detection transform passed "
+                    f"to `transform` to accept two args: an input "
+                    f"image and a COCO JSON dictionary, instead "
+                    f"got {len(sig)} parameters."
+                )
             return transform
 
         # An `albumentations` transform to be applied to the image. This
         # wraps the transform into a method which treats it as a regular
         # functional transform, e.g. no keyword arguments (for easy use).
-        elif 'albumentations' in transform.__module__:
+        elif "albumentations" in transform.__module__:
             return AlbumentationsTransformCOCO(transform)
 
         # Another type of transform, most likely some form of transform
         # class. No checks are applied here, since we can't account for
         # each of the potential cases of the transformations.
         return transform
-
-
diff --git a/agml/data/metadata.py b/agml/data/metadata.py
index 770fd9d8..2da24917 100644
--- a/agml/data/metadata.py
+++ b/agml/data/metadata.py
@@ -12,28 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import collections
 import io
 import re
 import sys
-import yaml
-import collections
 from typing import Iterable
 
-from agml.framework import AgMLSerializable
+import yaml
+
 import agml.utils.logging as logging
+from agml.framework import AgMLSerializable
+from agml.utils.data import copyright_print, load_citation_sources, load_public_sources, maybe_you_meant
 from agml.utils.general import has_nested_dicts
-from agml.utils.data import (
-    load_public_sources, load_citation_sources, maybe_you_meant, copyright_print
-)
-
 
 # Named tuples which are used by the metadata.
-Tasks = collections.namedtuple('Tasks', ['ml', 'ag'])
-Location = collections.namedtuple('Location', ['continent', 'country'])
-ImageStats = collections.namedtuple('ImageStats', ['mean', 'std'])
+Tasks = collections.namedtuple("Tasks", ["ml", "ag"])
+Location = collections.namedtuple("Location", ["continent", "country"])
+ImageStats = collections.namedtuple("ImageStats", ["mean", "std"])
 
 
-def make_metadata(name, meta = None):
+def make_metadata(name, meta=None):
     """Creates the metadata object for the dataset.
 
     For datasets in the AgML public data repository, this simply returns
@@ -43,7 +41,7 @@ def make_metadata(name, meta = None):
     """
     if isinstance(name, DatasetMetadata):
         name = name.name
-    if isinstance(name, (list, tuple, set, frozenset)): # a single dataset
+    if isinstance(name, (list, tuple, set, frozenset)):  # a single dataset
         name = next(iter(name))
     if name in load_public_sources().keys():
         return DatasetMetadata(name)
@@ -52,13 +50,13 @@ def make_metadata(name, meta = None):
 
 class _MetadataDict(dict):
     """Dictionary subclass that throws a custom error for metadata accesses."""
-    def __init__(self, *args, dataset = None, **kwargs):
+
+    def __init__(self, *args, dataset=None, **kwargs):
         if dataset is None:
-            raise ValueError(
-                "Cannot instantiate metadata dictionary without the dataset name.")
+            raise ValueError("Cannot instantiate metadata dictionary without the dataset name.")
         super(_MetadataDict, self).__init__(*args, **kwargs)
         self._dataset = dataset
-        self._custom = kwargs.get('custom', False)
+        self._custom = kwargs.get("custom", False)
 
     def __getitem__(self, item):
         try:
@@ -68,10 +66,12 @@ def __getitem__(self, item):
                 raise KeyError(
                     f"The provided custom dataset '{self._dataset}' has no "
                     f"associated metadata '{item}'. Please provide this when"
-                    f"instantiating the loader if you want to use it.")
+                    f"instantiating the loader if you want to use it."
+                )
             raise KeyError(
                 f"The dataset '{self._dataset}' is missing metadata '{item}'. "
-                f"Please bring this issue to the attention of the AgML team.")
+                f"Please bring this issue to the attention of the AgML team."
+            )
 
 
 class DatasetMetadata(AgMLSerializable):
@@ -98,7 +98,8 @@ class DatasetMetadata(AgMLSerializable):
     property of this class, but any additional info that is not can
     be accessed by treating the `info` object as a dictionary.
     """
-    serializable = frozenset(('name', 'metadata', 'citation_meta'))
+
+    serializable = frozenset(("name", "metadata", "citation_meta"))
     is_custom_dataset = False
 
     def __init__(self, name):
@@ -131,21 +132,18 @@ def _load_source_info(self, name):
 
         source_info = load_public_sources()
         if name not in source_info.keys():
-            if name.replace('-', '_') not in source_info.keys():
+            if name.replace("-", "_") not in source_info.keys():
                 msg = f"Received invalid public source: '{name}'."
                 msg = maybe_you_meant(name, msg)
                 raise ValueError(msg)
             else:
-                logging.log(
-                    f"Interpreted dataset '{name}' as '{name.replace('-', '_')}.'")
-                name = name.replace('-', '_')
+                logging.log(f"Interpreted dataset '{name}' as '{name.replace('-', '_')}.'")
+                name = name.replace("-", "_")
         self._name = name
-        self._metadata = _MetadataDict(
-            **source_info[name], dataset = name)
+        self._metadata = _MetadataDict(**source_info[name], dataset=name)
 
         # Load citation information.
-        self._citation_meta = _MetadataDict(
-            **load_citation_sources()[name], dataset = name)
+        self._citation_meta = _MetadataDict(**load_citation_sources()[name], dataset=name)
 
     def __getattr__(self, key):
         try:
@@ -156,8 +154,11 @@ def __getattr__(self, key):
                 return self._metadata[key]
             raise AttributeError(
                 maybe_you_meant(
-                    key, f"Received invalid info parameter: '{key}'.",
-                    source = self._metadata.keys()))
+                    key,
+                    f"Received invalid info parameter: '{key}'.",
+                    source=self._metadata.keys(),
+                )
+            )
 
     def __getitem__(self, key):
         return getattr(self, key)
@@ -168,45 +169,45 @@ def name(self):
 
     @property
     def num_images(self):
-        return int(float(self._metadata['n_images']))
+        return int(float(self._metadata["n_images"]))
 
     @property
     def tasks(self):
         """Returns the ML and Agriculture tasks for this dataset."""
-        ml_task, ag_task = self._metadata['ml_task'], self._metadata['ag_task']
-        return Tasks(ml = ml_task, ag = ag_task)
+        ml_task, ag_task = self._metadata["ml_task"], self._metadata["ag_task"]
+        return Tasks(ml=ml_task, ag=ag_task)
 
     @property
     def location(self):
         """Returns the continent and country in which the dataset was made."""
-        continent, country = self._metadata['location'].values()
-        return Location(continent = continent, country = country)
+        continent, country = self._metadata["location"].values()
+        return Location(continent=continent, country=country)
 
     @property
     def image_stats(self):
         """Returns the mean and standard deviation of the RGB images."""
-        mean, std = self._metadata['stats'].values()
-        return ImageStats(mean = mean, std = std)
+        mean, std = self._metadata["stats"].values()
+        return ImageStats(mean=mean, std=std)
 
     @property
     def sensor_modality(self):
-        return self._metadata['sensor_modality']
+        return self._metadata["sensor_modality"]
 
     @property
     def image_format(self):
-        return self._metadata['input_data_format']
+        return self._metadata["input_data_format"]
 
     @property
     def annotation_format(self):
-        return self._metadata['annotation_format']
+        return self._metadata["annotation_format"]
 
     @property
     def docs(self):
-        return self._metadata['docs_url']
+        return self._metadata["docs_url"]
 
     @property
     def num_to_class(self):
-        mapping = self._metadata['classes']
+        mapping = self._metadata["classes"]
         if has_nested_dicts(mapping):
             out = {}
             for class_type in mapping.keys():
@@ -221,7 +222,7 @@ def num_to_class(self):
 
     @property
     def class_to_num(self):
-        mapping = self._metadata['classes']
+        mapping = self._metadata["classes"]
         if has_nested_dicts(mapping):
             out = {}
             for class_type in mapping.keys():
@@ -236,7 +237,7 @@ def class_to_num(self):
 
     @property
     def classes(self):
-        classes = self._metadata['classes']
+        classes = self._metadata["classes"]
         if has_nested_dicts(classes):
             return {k: list(d.values()) for k, d in classes.items()}
         return list(classes.values())
@@ -247,19 +248,19 @@ def num_classes(self):
 
     @property
     def license(self):
-        if self._citation_meta['license'] == '':
+        if self._citation_meta["license"] == "":
             return None
-        return self._citation_meta['license']
+        return self._citation_meta["license"]
 
     @property
     def citation(self):
-        if self._citation_meta['citation'] == '':
+        if self._citation_meta["citation"] == "":
             return None
-        return self._citation_meta['citation']
+        return self._citation_meta["citation"]
 
     @property
     def external_image_sources(self):
-        return self._metadata['external_image_sources']
+        return self._metadata["external_image_sources"]
 
     def summary(self):
         """Prints out a summary of the dataset information.
@@ -270,39 +271,41 @@ def summary(self):
         that this does not return anything, so it shouldn't be called
         as `print(loader.info.summary())`, just `loader.info.summary()`.
         """
+
         def _bold(msg):
-            return '\033[1m' + msg + '\033[0m'
-        def _bold_yaml(msg): # noqa
-            return '<|>' + msg + '<|>'
+            return "\033[1m" + msg + "\033[0m"
+
+        def _bold_yaml(msg):  # noqa
+            return "<|>" + msg + "<|>"
 
         _SWITCH_NAMES = {
-            'ml_task': "Machine Learning Task",
-            'ag_task': "Agricultural Task",
-            'real_synthetic': 'Real Or Synthetic',
-            'n_images': "Number of Images",
-            'docs_url': "Documentation"
+            "ml_task": "Machine Learning Task",
+            "ag_task": "Agricultural Task",
+            "real_synthetic": "Real Or Synthetic",
+            "n_images": "Number of Images",
+            "docs_url": "Documentation",
         }
 
         formatted_metadata = {}
         for key, value in self._metadata.items():
-            name = key.replace('_', ' ').title()
+            name = key.replace("_", " ").title()
             if key in _SWITCH_NAMES.keys():
                 name = _SWITCH_NAMES[key]
-            if name == 'Crop Types':
+            if name == "Crop Types":
                 value = {int(k): v for k, v in value.items()}
-            if name == 'Number of Images':
+            if name == "Number of Images":
                 value = int(value)
             formatted_metadata[_bold_yaml(name)] = value
 
         stream = io.StringIO()
-        yaml.dump(formatted_metadata, stream, sort_keys = False)
+        yaml.dump(formatted_metadata, stream, sort_keys=False)
         content = stream.getvalue()
-        content = re.sub('<\\|>(.*?)<\\|>', _bold(r'\1'), content)
-        header = '=' * 20 + ' DATASET SUMMARY ' + '=' * 20
+        content = re.sub("<\\|>(.*?)<\\|>", _bold(r"\1"), content)
+        header = "=" * 20 + " DATASET SUMMARY " + "=" * 20
         print(header)
         print(_bold("Name") + f": {self._name}")
-        print(content, end = '')
-        print('=' * 57)
+        print(content, end="")
+        print("=" * 57)
         sys.stdout.flush()
 
     def citation_summary(self):
@@ -325,10 +328,11 @@ class CustomDatasetMetadata(DatasetMetadata):
     extent of the rest of the metadata, and so this class is used
     to wrap the provided metadata and infer other arguments instead.
     """
+
     serializable = frozenset(("name", "metadata"))
     is_custom_dataset = True
 
-    def __init__(self, name, meta): # noqa
+    def __init__(self, name, meta):  # noqa
         if meta is None:
             msg = f"Received invalid public source: '{name}'."
             out_msg = maybe_you_meant(name, msg)
@@ -342,17 +346,18 @@ def _load_info(self, name, meta):
         """Loads the provided metadata into the class."""
         # Check that the necessary categories (the task and a list of classes)
         # have been provided, otherwise the loader will not be able to function.
-        if 'task' not in meta:
+        if "task" not in meta:
             raise ValueError("Expected a `task` when instantiating a custom loader.")
-        if 'classes' not in meta:
+        if "classes" not in meta:
             raise ValueError("Expected a list of classes when instantiating a custom loader.")
 
         # Create a custom dictionary of metadata.
         self._name = name
         self._metadata = _MetadataDict(
-            {'ml_task': meta['task'], 'ag_task': meta.get('ag_task', None),
-             **meta}, dataset = name)
-        self._metadata['classes'] = {str(i + 1): c for i, c in enumerate(meta['classes'])}
+            {"ml_task": meta["task"], "ag_task": meta.get("ag_task", None), **meta},
+            dataset=name,
+        )
+        self._metadata["classes"] = {str(i + 1): c for i, c in enumerate(meta["classes"])}
 
         # There is no citation information necessary for custom datasets.
         self._citation_meta = None
@@ -367,8 +372,3 @@ def citation(self):
 
     def citation_summary(self):  # no citations for custom datasets.
         print("Custom Dataset: No Citation Information Available.")
-
-
-
-
-
diff --git a/agml/data/multi_loader.py b/agml/data/multi_loader.py
index 571c6d1c..0f9f45bb 100644
--- a/agml/data/multi_loader.py
+++ b/agml/data/multi_loader.py
@@ -12,45 +12,47 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
+import collections
 import json
+import os
 import types
-import collections
-from typing import Union
 from decimal import Decimal, getcontext
+from typing import Union
 
 import numpy as np
 
-from agml.framework import AgMLSerializable
-from agml.data.metadata import DatasetMetadata
-from agml.data.loader import AgMLDataLoader
-from agml.data.exporters.yolo import export_yolo
-from agml.utils.general import (
-    resolve_list_value, NoArgument
-)
-from agml.utils.random import seed_context, inject_random_state
-from agml.utils.image import consistent_shapes
-from agml.utils.logging import log
 from agml.backend.config import SUPER_BASE_DIR
 from agml.backend.tftorch import (
-    get_backend, set_backend,
-    user_changed_backend, StrictBackendError,
-    is_array_like, convert_to_batch
+    StrictBackendError,
+    convert_to_batch,
+    get_backend,
+    is_array_like,
+    set_backend,
+    user_changed_backend,
 )
+from agml.data.exporters.yolo import export_yolo
+from agml.data.loader import AgMLDataLoader
+from agml.data.metadata import DatasetMetadata
+from agml.framework import AgMLSerializable
+from agml.utils.general import NoArgument, resolve_list_value
+from agml.utils.image import consistent_shapes
+from agml.utils.logging import log
+from agml.utils.random import inject_random_state, seed_context
 from agml.viz.general import show_sample
 
 
 class CollectionWrapper(AgMLSerializable):
     """Wraps a collection of items and calls their attributes and methods."""
-    serializable = frozenset(('collection', 'keys'))
 
-    def __init__(self, collection, keys = None, ignore_types = False):
+    serializable = frozenset(("collection", "keys"))
+
+    def __init__(self, collection, keys=None, ignore_types=False):
         self._collection = collection
         if not ignore_types:
             if not all(isinstance(c, type(collection[0])) for c in collection):
                 raise TypeError(
-                    f"Items in a collection should all be of the "
-                    f"same type, got {[type(i) for i in collection]}")
+                    f"Items in a collection should all be of the " f"same type, got {[type(i) for i in collection]}"
+                )
         self._keys = keys
 
     def __len__(self):
@@ -70,7 +72,7 @@ def get_attributes(self, attr, include_names=False):
             return {c.name: getattr(c, attr) for c in self._collection}
         return [getattr(c, attr) for c in self._collection]
 
-    def call_method(self, method, args = None, kwargs = None):
+    def call_method(self, method, args=None, kwargs=None):
         if kwargs is None:
             kwargs = {}
         if args is None:
@@ -78,13 +80,12 @@ def call_method(self, method, args = None, kwargs = None):
         elif isinstance(args, tuple):
             if not len(args) == len(self._collection):
                 raise IndexError(
-                    f"Got {len(args)} unique arguments for a "
-                    f"collection of length {len(self._collection)}.")
-            return [getattr(c, method)(arg, **kwargs)
-                    for c, arg in zip(self._collection, args)]
+                    f"Got {len(args)} unique arguments for a " f"collection of length {len(self._collection)}."
+                )
+            return [getattr(c, method)(arg, **kwargs) for c, arg in zip(self._collection, args)]
         return [getattr(c, method)(*args, **kwargs) for c in self._collection]
 
-    def apply(self, method, args = None):
+    def apply(self, method, args=None):
         if args is None:
             for c in self._collection:
                 method(c)
@@ -102,15 +103,15 @@ class MultiDatasetMetadata(AgMLSerializable):
     dictionary with all the values for the corresponding
     datasets rather than just a single value.
     """
+
     serializable = frozenset(("names", "metas", "task"))
 
     def __init__(self, datasets):
         # Build a collection of metadata objects.
         self._names = datasets
-        self._metas = CollectionWrapper(
-            [DatasetMetadata(d) for d in datasets])
+        self._metas = CollectionWrapper([DatasetMetadata(d) for d in datasets])
         self._validate_tasks()
-        
+
     @classmethod
     def _from_collection(cls, metas):
         """Instantiates a `MultiDatasetMetadata` object from a collection."""
@@ -119,18 +120,20 @@ def _from_collection(cls, metas):
 
         # We need to ignore types since some metadata objects might be
         # regular `DatasetMetadata`, but some might be `CustomDatasetMetadata`.
-        obj._metas = CollectionWrapper(metas, ignore_types = True)
+        obj._metas = CollectionWrapper(metas, ignore_types=True)
         obj._validate_tasks()
         return obj
 
     def _validate_tasks(self):
         # For a collection of datasets to work, they all need
         # to be of the same task. This is a check of this.
-        tasks = self._metas.get_attributes('tasks')
+        tasks = self._metas.get_attributes("tasks")
         if not all(tasks[0].ml == t.ml for t in tasks):
-            raise ValueError("To use a collection of datasets, all of them "
-                             f"must be of the same task. Got tasks {tasks} "
-                             f"for the provided datasets {self._names}.")
+            raise ValueError(
+                "To use a collection of datasets, all of them "
+                f"must be of the same task. Got tasks {tasks} "
+                f"for the provided datasets {self._names}."
+            )
         self._task = tasks[0]
 
     @property
@@ -150,8 +153,7 @@ def __getattr__(self, attr):
 
             # If it is a property, then we need to return something.
             if isinstance(obj, property):
-                return {k: v for k, v in zip(
-                    self._names, self._metas.get_attributes(attr))}
+                return {k: v for k, v in zip(self._names, self._metas.get_attributes(attr))}
 
             # If it is a method, then it is just printing.
             if isinstance(obj, types.FunctionType):
@@ -165,47 +167,49 @@ def __getattr__(self, attr):
 
 class AnnotationRemap(AgMLSerializable):
     """A helper class to remap annotation labels for multiple datasets."""
-    serializable = frozenset((
-        "general_class_to_num", "num_to_class", "task",
-        "generalize_class_detections"))
-    
-    def __init__(self, general_class_to_num, num_to_class,
-                 task, generalize_class_detections = False):
+
+    serializable = frozenset(("general_class_to_num", "num_to_class", "task", "generalize_class_detections"))
+
+    def __init__(
+        self,
+        general_class_to_num,
+        num_to_class,
+        task,
+        generalize_class_detections=False,
+    ):
         self._task = task
         self._num_to_class = num_to_class
         self._general_class_to_num = general_class_to_num
         self._generalize_class_detections = generalize_class_detections
-        
+
     def __call__(self, contents, name):
         """Re-maps the annotation for the new, multi-dataset mapping."""
         image, annotations = contents
 
         # For image classification, simply re-map the label number.
-        if self._task == 'image_classification':
-            annotations = self._general_class_to_num[
-                self._num_to_class[name][annotations].lower()]
+        if self._task == "image_classification":
+            annotations = self._general_class_to_num[self._num_to_class[name][annotations].lower()]
 
         # For semantic segmentation, re-map the mask IDs.
-        if self._task == 'semantic_segmentation':
-            unique_values = np.unique(annotations)[1:] # skip background
-            new_values = np.array([self._general_class_to_num[
-                self._num_to_class[name][c].lower()]
-                                for c in unique_values])
+        if self._task == "semantic_segmentation":
+            unique_values = np.unique(annotations)[1:]  # skip background
+            new_values = np.array(
+                [self._general_class_to_num[self._num_to_class[name][c].lower()] for c in unique_values]
+            )
             for u, n in zip(unique_values, new_values):
                 annotations[np.where(annotations == u)[0]] = n
 
         # For object detection, also just remap the annotation ID.
-        if self._task == 'object_detection':
+        if self._task == "object_detection":
             if self._generalize_class_detections:
-                annotations['category_id'] = np.ones_like(
-                    annotations['category_id'])
+                annotations["category_id"] = np.ones_like(annotations["category_id"])
             else:
-                category_ids = annotations['category_id']
-                category_ids[np.where(category_ids == 0)[0]] = 1 # fix
-                new_ids = np.array([self._general_class_to_num[
-                    self._num_to_class[name][c].lower()]
-                                    for c in category_ids])
-                annotations['category_id'] = new_ids
+                category_ids = annotations["category_id"]
+                category_ids[np.where(category_ids == 0)[0]] = 1  # fix
+                new_ids = np.array(
+                    [self._general_class_to_num[self._num_to_class[name][c].lower()] for c in category_ids]
+                )
+                annotations["category_id"] = new_ids
         return image, annotations
 
 
@@ -221,13 +225,26 @@ class AgMLMultiDatasetLoader(AgMLSerializable):
     `AgMLDataLoader` objects, and draws upon similar functionality
     to the `DataManager` in order to access data from multiple objects.
     """
+
     IS_MULTI_DATASET: bool = True
 
     serializable = frozenset(
-        ('info', 'loaders', 'loader_accessors', 'class_meta',
-         'set_to_keys', 'bounds', 'batch_size', 'shuffle_data',
-         'data_distributions', 'is_split', 'train_data',
-         'val_data', 'test_data'))
+        (
+            "info",
+            "loaders",
+            "loader_accessors",
+            "class_meta",
+            "set_to_keys",
+            "bounds",
+            "batch_size",
+            "shuffle_data",
+            "data_distributions",
+            "is_split",
+            "train_data",
+            "val_data",
+            "test_data",
+        )
+    )
 
     def __init__(self, datasets, **kwargs):
         """Instantiates an `AgMLDataLoader` with multiple datasets."""
@@ -263,18 +280,15 @@ def __init__(self, datasets, **kwargs):
         # in the order provided, where index 0 represents the first item
         # in the first dataset, and index 1 represents the last item in
         # the last dataset. Batching works in a similar way.
-        self._loader_accessors = np.arange(
-            sum(v for v in self._info.num_images.values()))
+        self._loader_accessors = np.arange(sum(v for v in self._info.num_images.values()))
         sets = self._info.num_images.keys()
         bounds = np.cumsum(list(self._info.num_images.values())).tolist()
-        bounds = (0, ) + (*bounds, )
+        bounds = (0,) + (*bounds,)
         self._set_to_keys = {}
         self._bounds = {s: b for s, b in zip(sets, bounds)}
         for i, set_ in enumerate(sets):
             value = 0 if i == 0 else 1
-            self._set_to_keys.update(dict.fromkeys(
-                np.arange(bounds[i] - value,
-                          bounds[i + 1] + 1), set_))
+            self._set_to_keys.update(dict.fromkeys(np.arange(bounds[i] - value, bounds[i + 1] + 1), set_))
 
         # The batch size is modified similarly like the `DataManager`.
         # Since all of the data loaders should have the same properties,
@@ -286,7 +300,7 @@ def __init__(self, datasets, **kwargs):
         # Shuffling in a multi-dataset loader takes place on a high-level.
         # The contents of the actual datasets themselves are not shuffled.
         # Instead, the accessor array is shuffled (like the DataManager).
-        self._shuffle_data = kwargs.get('shuffle', True)
+        self._shuffle_data = kwargs.get("shuffle", True)
         if self._shuffle_data:
             self.shuffle(self._shuffle_data)
 
@@ -300,14 +314,14 @@ def __init__(self, datasets, **kwargs):
         # before any other transforms are applied, and in any case.
         self._loaders.apply(
             lambda x: x._manager._train_manager._set_annotation_remap_hook(
-                AnnotationRemap(
-                    self.class_to_num, self._info.num_to_class, self.task)))
+                AnnotationRemap(self.class_to_num, self._info.num_to_class, self.task)
+            )
+        )
 
         # We can't use the `auto` resizing mode for the resizing manager,
         # because of the complexity of trying to make it work with multiple
         # different data types. So, disable auto mode to prevent errors.
-        self._loaders.apply(
-            lambda x: x._manager._resize_manager.disable_auto())
+        self._loaders.apply(lambda x: x._manager._resize_manager.disable_auto())
 
         # The data is not split to begin with. So, we set the split
         # parameter to false and store all of the split datasets themselves
@@ -325,43 +339,38 @@ def __init__(self, datasets, **kwargs):
 
         # Total number of images in the entire dataset.
         self._num_images = sum(self._info.num_images.values())
-        
+
     @classmethod
     def _instantiate_from_collection(cls, *loaders, classes):
         """Instantiates an `AgMLMultiDatasetLoader` directly from a collection.
-        
+
         This method is, in essence, a wrapper around the actual `__init__`
         method for the multi-loader, but one which takes into account the fact
         that the loaders are already instantiated, and thus works around those
-        already-provided parameters, rather than starting from scratch. 
+        already-provided parameters, rather than starting from scratch.
         """
         obj = AgMLMultiDatasetLoader.__new__(AgMLMultiDatasetLoader)
-        
+
         # Create the custom dataset metadata wrapper.
-        obj._info = MultiDatasetMetadata._from_collection([
-            loader.info for loader in loaders])
-        
+        obj._info = MultiDatasetMetadata._from_collection([loader.info for loader in loaders])
+
         # Add the loaders and adapt classes.
-        obj._loaders = CollectionWrapper(
-            loaders, keys = [loader.info.name for loader in loaders])
-        obj._adapt_classes(cls = classes)
-        
+        obj._loaders = CollectionWrapper(loaders, keys=[loader.info.name for loader in loaders])
+        obj._adapt_classes(cls=classes)
+
         # The remaining contents here are directly copied from the above
         # `__init__` method, without comments (see above for information):
         # Construct the accessor array.
-        obj._loader_accessors = np.arange(
-            sum(v for v in obj._info.num_images.values()))
+        obj._loader_accessors = np.arange(sum(v for v in obj._info.num_images.values()))
         sets = obj._info.num_images.keys()
         bounds = np.cumsum(list(obj._info.num_images.values())).tolist()
-        bounds = (0, ) + (*bounds, )
+        bounds = (0,) + (*bounds,)
         obj._set_to_keys = {}
         obj._bounds = {s: b for s, b in zip(sets, bounds)}
         for i, set_ in enumerate(sets):
             value = 0 if i == 0 else 1
-            obj._set_to_keys.update(dict.fromkeys(
-                np.arange(bounds[i] - value,
-                          bounds[i + 1] + 1), set_))
-            
+            obj._set_to_keys.update(dict.fromkeys(np.arange(bounds[i] - value, bounds[i + 1] + 1), set_))
+
         # Set the batch size and shuffling.
         obj._batch_size = None
         obj._make_batch = obj._loaders[0]._manager._train_manager.make_batch
@@ -372,11 +381,11 @@ def _instantiate_from_collection(cls, *loaders, classes):
         # Transform annotations and resizing.
         obj._loaders.apply(
             lambda x: x._manager._train_manager._set_annotation_remap_hook(
-                AnnotationRemap(
-                    obj.class_to_num, obj._info.num_to_class, obj.task)))
-        obj._loaders.apply(
-            lambda x: x._manager._resize_manager.disable_auto())
-        
+                AnnotationRemap(obj.class_to_num, obj._info.num_to_class, obj.task)
+            )
+        )
+        obj._loaders.apply(lambda x: x._manager._resize_manager.disable_auto())
+
         # Finalize parameters.
         obj._is_split = False
         obj._train_data = None
@@ -394,7 +403,7 @@ def _instantiate_from_collection(cls, *loaders, classes):
     def __len__(self):
         # Return the length of the data, subject to batching.
         return self._data_length()
-            
+
     def __getitem__(self, indexes: Union[int, slice, tuple, list]):
         # The `__getitem__` logic adopts the `DataManager` approach
         # towards getting multiple items, wrapped into this class.
@@ -405,8 +414,7 @@ def __getitem__(self, indexes: Union[int, slice, tuple, list]):
             indexes = [indexes]
         for idx in indexes:
             if idx not in range(len(self)):
-                raise IndexError(f"Index {idx} out of range of "
-                                 f"AgMLDataLoader length: {len(self)}.")
+                raise IndexError(f"Index {idx} out of range of " f"AgMLDataLoader length: {len(self)}.")
         return self._get_item_impl(resolve_list_value(indexes))
 
     def __iter__(self):
@@ -453,15 +461,13 @@ def copy_state(self, loader):
         # a multi-loader, then only copy the state of its first loader.
         if isinstance(loader, AgMLMultiDatasetLoader):
             loader = loader._loaders[0]
-        self._loaders.apply(
-            lambda x: x.copy_state(loader)
-        )
+        self._loaders.apply(lambda x: x.copy_state(loader))
 
     def _make_loaders(self, datasets, **kwargs):
         """Constructs the loaders for the datasets in the collection."""
         # Get and validate the `dataset_path` argument.
-        if 'dataset_path' in kwargs:
-            dataset_path = kwargs.get('dataset_path')
+        if "dataset_path" in kwargs:
+            dataset_path = kwargs.get("dataset_path")
             if isinstance(dataset_path, collections.Sequence):
                 if not len(datasets) == len(dataset_path):
                     raise IndexError(
@@ -469,19 +475,18 @@ def _make_loaders(self, datasets, **kwargs):
                         f"multi-dataset `AgMLDataLoader`, but it is not "
                         f"the same length as the number of datasets: "
                         f"{len(datasets)} datasets ({datasets}) but "
-                        f"{len(dataset_path)} paths ({dataset_path}).")
+                        f"{len(dataset_path)} paths ({dataset_path})."
+                    )
             elif isinstance(dataset_path, str):
                 dataset_path = [dataset_path] * len(datasets)
         else:
             dataset_path = False
-        kwargs.update({'dataset_path': dataset_path})
+        kwargs.update({"dataset_path": dataset_path})
 
         # Create all the loaders.
-        self._loaders = CollectionWrapper([
-            AgMLDataLoader(dataset, **kwargs) for dataset in datasets],
-            keys = datasets)
+        self._loaders = CollectionWrapper([AgMLDataLoader(dataset, **kwargs) for dataset in datasets], keys=datasets)
 
-    def _adapt_classes(self, cls = None):
+    def _adapt_classes(self, cls=None):
         """Adapts the classes in the loader."""
         # Get all the unique classes in the loader.
         classes = self._info.classes.values()
@@ -491,22 +496,21 @@ def _adapt_classes(self, cls = None):
 
         # Check that they match the given classes, if such a list is passed.
         if cls is not None:
-            if not set(cls) == set(unique_classes): # noqa
+            if not set(cls) == set(unique_classes):  # noqa
                 raise ValueError(
                     f"Given list of classes {cls} to `AgMLDataLoader.merge`, "
                     f"but calculated classes {unique_classes}. Check that the "
-                    f"given classes match the actual classes in the given datasets.")
+                    f"given classes match the actual classes in the given datasets."
+                )
             unique_classes = cls
 
         # Create a class metadata storing all of the unique
         # classes belonging to this loader and their mappings.
         self._class_meta = {
-            'classes': unique_classes,
-            'num_classes': len(unique_classes),
-            'class_to_num': {
-                v: k + 1 for k, v in enumerate(unique_classes)},
-            'num_to_class': {
-                k + 1: v for k, v in enumerate(unique_classes)}
+            "classes": unique_classes,
+            "num_classes": len(unique_classes),
+            "class_to_num": {v: k + 1 for k, v in enumerate(unique_classes)},
+            "num_to_class": {k + 1: v for k, v in enumerate(unique_classes)},
         }
 
     def _data_length(self):
@@ -516,7 +520,7 @@ def _data_length(self):
     @property
     def dataset_root(self):
         """Returns a list of paths to the datasets in use."""
-        return self._loaders.get_attributes('dataset_root')
+        return self._loaders.get_attributes("dataset_root")
 
     @property
     def info(self):
@@ -547,22 +551,22 @@ def num_images(self):
     @property
     def classes(self):
         """Returns the classes that the dataset is predicting."""
-        return self._class_meta['classes']
+        return self._class_meta["classes"]
 
     @property
     def num_classes(self):
         """Returns the number of classes in the dataset."""
-        return self._class_meta['num_classes']
+        return self._class_meta["num_classes"]
 
     @property
     def num_to_class(self):
         """Returns a mapping from a number to a class label."""
-        return self._class_meta['num_to_class']
+        return self._class_meta["num_to_class"]
 
     @property
     def class_to_num(self):
         """Returns a mapping from a class label to a number."""
-        return self._class_meta['class_to_num']
+        return self._class_meta["class_to_num"]
 
     @property
     def data_distributions(self):
@@ -578,43 +582,38 @@ def _generate_split_loader(self, loaders, split):
         """Generates a split `AgMLDataLoader`."""
         # Check if the data split exists.
         if any(loader is None for loader in loaders):
-            raise ValueError(
-                f"Attempted to access split loader {split} when "
-                f"parent loader has not been split.")
+            raise ValueError(f"Attempted to access split loader {split} when " f"parent loader has not been split.")
 
         # Create a new `CollectionWrapper` around the datasets.
-        new_collection = CollectionWrapper(loaders, keys = [l_.name for l_ in loaders])
+        new_collection = CollectionWrapper(loaders, keys=[l_.name for l_ in loaders])
 
         # Get the state of the current loader and update it
         # with the new collection of loaders. Then, update
         # the accessors and number of images with the newly
         # reduced quantity (due to the splitting of data).
         loader_state = self.copy().__getstate__()
-        loader_state['loaders'] = new_collection
+        loader_state["loaders"] = new_collection
         total_num_images = sum(len(loader) for loader in loaders)
-        data_distributions = {
-            loader.name: len(loader) for loader in loaders}
-        loader_state['data_distributions'] = data_distributions
+        data_distributions = {loader.name: len(loader) for loader in loaders}
+        loader_state["data_distributions"] = data_distributions
         accessors = np.arange(0, total_num_images)
         if self._shuffle_data:
             np.random.shuffle(accessors)
-        loader_state['loader_accessors'] = accessors
-        batch_size = loader_state.pop('batch_size')
-        loader_state['batch_size'] = None
+        loader_state["loader_accessors"] = accessors
+        batch_size = loader_state.pop("batch_size")
+        loader_state["batch_size"] = None
 
         # Re-generate the mapping for bounds.
         sets = self._info.num_images.keys()
         bound_ranges = np.cumsum([len(loader) for loader in loaders]).tolist()
-        bound_ranges = (0, ) + (*bound_ranges, )
+        bound_ranges = (0,) + (*bound_ranges,)
         set_to_keys = {}
         bounds = {s: b for s, b in zip(sets, bound_ranges)}
         for i, set_ in enumerate(sets):
             value = 0 if i == 0 else 1
-            set_to_keys.update(dict.fromkeys(
-                np.arange(bound_ranges[i],
-                          bound_ranges[i + 1] + value), set_))
-        loader_state['set_to_keys'] = set_to_keys
-        loader_state['bounds'] = bounds
+            set_to_keys.update(dict.fromkeys(np.arange(bound_ranges[i], bound_ranges[i + 1] + value), set_))
+        loader_state["set_to_keys"] = set_to_keys
+        loader_state["bounds"] = bounds
 
         # Create the new loader from the updated state.
         new_loader = AgMLMultiDatasetLoader.__new__(AgMLMultiDatasetLoader)
@@ -622,13 +621,13 @@ def _generate_split_loader(self, loaders, split):
 
         # Batching data should be re-done independently.
         if batch_size is not None:
-            new_loader.batch(batch_size = batch_size)
+            new_loader.batch(batch_size=batch_size)
 
         # Block out all the splits of the already split
         # loader and set the `_is_split` attribute to True,
         # preventing future splits, and return.
-        for attr in ['train', 'val', 'test']:
-            setattr(new_loader, f'_{attr}_content', None)
+        for attr in ["train", "val", "test"]:
+            setattr(new_loader, f"_{attr}_content", None)
         new_loader._is_split = True
         return new_loader
 
@@ -637,8 +636,7 @@ def train_data(self):
         """Stores the `train` split of the data in the loader."""
         if isinstance(self._train_data, AgMLMultiDatasetLoader):
             return self._train_data
-        self._train_data = self._generate_split_loader(
-            self._loaders.get_attributes('train_data'), split = 'train')
+        self._train_data = self._generate_split_loader(self._loaders.get_attributes("train_data"), split="train")
         return self._train_data
 
     @property
@@ -646,8 +644,7 @@ def val_data(self):
         """Stores the `val` split of the data in the loader."""
         if isinstance(self._val_data, AgMLMultiDatasetLoader):
             return self._val_data
-        self._val_data = self._generate_split_loader(
-            self._loaders.get_attributes('val_data'), split = 'val')
+        self._val_data = self._generate_split_loader(self._loaders.get_attributes("val_data"), split="val")
         self._val_data.eval()
         return self._val_data
 
@@ -656,8 +653,7 @@ def test_data(self):
         """Stores the `test` split of the data in the loader."""
         if isinstance(self._test_data, AgMLMultiDatasetLoader):
             return self._test_data
-        self._test_data = self._generate_split_loader(
-            self._loaders.get_attributes('test_data'), split = 'test')
+        self._test_data = self._generate_split_loader(self._loaders.get_attributes("test_data"), split="test")
         self._test_data.eval()
         return self._test_data
 
@@ -684,7 +680,7 @@ def eval(self):
         -------
         The `AgMLDataLoader` object.
         """
-        self._loaders.call_method('eval')
+        self._loaders.call_method("eval")
         return self
 
     def disable_preprocessing(self):
@@ -705,7 +701,7 @@ def disable_preprocessing(self):
         -------
         The `AgMLDataLoader` object.
         """
-        self._loaders.call_method('disable_preprocessing')
+        self._loaders.call_method("disable_preprocessing")
         return self
 
     def reset_preprocessing(self):
@@ -721,7 +717,7 @@ def reset_preprocessing(self):
         -------
         The `AgMLDataLoader` object.
         """
-        self._loaders.call_method('reset_preprocessing')
+        self._loaders.call_method("reset_preprocessing")
         return self
 
     def on_epoch_end(self):
@@ -731,7 +727,7 @@ def on_epoch_end(self):
         from `tf.keras.utils.Sequence`, then this method will shuffle the
         dataset on the end of each epoch to improve training.
         """
-        self._loaders.call_method('on_epoch_end')
+        self._loaders.call_method("on_epoch_end")
 
     def as_keras_sequence(self):
         """Sets the `DataLoader` in TensorFlow mode.
@@ -758,7 +754,7 @@ def as_keras_sequence(self):
         -------
         The `AgMLDataLoader` object.
         """
-        self._loaders.call_method('as_keras_sequence')
+        self._loaders.call_method("as_keras_sequence")
         return self
 
     def as_torch_dataset(self):
@@ -786,7 +782,7 @@ def as_torch_dataset(self):
         -------
         The `AgMLDataLoader` object.
         """
-        self._loaders.call_method('as_torch_dataset')
+        self._loaders.call_method("as_torch_dataset")
 
     @property
     def shuffle_data(self):
@@ -808,7 +804,7 @@ def shuffle_data(self, value):
             raise TypeError("Expected either `True` or `False` for 'shuffle_data'.")
         self._shuffle_data = value
 
-    def shuffle(self, seed = None):
+    def shuffle(self, seed=None):
         """Potentially shuffles the contents of the loader.
 
         If shuffling is enabled on this loader (`shuffle = False` has
@@ -855,6 +851,7 @@ def take_images(self):
         An `agml.data.ImageLoader` with the dataset images.
         """
         from agml.data.image_loader import ImageLoader
+
         return ImageLoader(self)
 
     def take_dataset(self, name) -> "AgMLDataLoader":
@@ -912,9 +909,7 @@ def take_random(self, k) -> "AgMLMultiDatasetLoader":
         if isinstance(k, float):
             # Check that 0.0 <= k <= 1.0.
             if not 0.0 <= k <= 1.0:
-                raise ValueError(
-                    "If passing a proportion to `take_class`, "
-                    "it should be in range [0.0, 1.0].")
+                raise ValueError("If passing a proportion to `take_class`, " "it should be in range [0.0, 1.0].")
 
             # Convert the proportion float to an absolute int. Note that
             # the method used is rounding up to the nearest int for cases
@@ -931,32 +926,31 @@ def take_random(self, k) -> "AgMLMultiDatasetLoader":
             if not 0 <= k <= self.num_images:
                 raise ValueError(
                     f"Received a request to take a random sampling of "
-                    f"{k} images, when the dataset has {self.num_images}.")
+                    f"{k} images, when the dataset has {self.num_images}."
+                )
 
             # Calculate the proportions. If the total sum is less than `k`,
             # add 1 to the dataset with the lowest number of images.
             getcontext().prec = 4  # noqa
             num_images = self.num_images
-            proportions = {key: int((Decimal(val) / Decimal(num_images)) * k)
-                            for key, val in self._data_distributions.items()}
+            proportions = {
+                key: int((Decimal(val) / Decimal(num_images)) * k) for key, val in self._data_distributions.items()
+            }
             if sum(proportions.values()) != num_images:
                 diff = sum(proportions.values()) - k
-                smallest_split = list(proportions.keys())[
-                    list(proportions.values()).index(
-                        min(proportions.values()))]
+                smallest_split = list(proportions.keys())[list(proportions.values()).index(min(proportions.values()))]
                 proportions[smallest_split] = proportions[smallest_split] - diff
             return self._generate_split_loader(
-                self._loaders.call_method(
-                    'take_random', tuple(proportions.values())), 'train')
+                self._loaders.call_method("take_random", tuple(proportions.values())),
+                "train",
+            )
 
         # Otherwise, raise an error.
         else:
-            raise TypeError(
-                f"Expected only an int or a float when "
-                f"taking a random split, got {type(k)}.")
+            raise TypeError(f"Expected only an int or a float when " f"taking a random split, got {type(k)}.")
 
     @inject_random_state
-    def split(self, train = None, val = None, test = None, shuffle = True):
+    def split(self, train=None, val=None, test=None, shuffle=True):
         """Splits the data into train, val and test splits.
 
         For this multi-dataset loader, an even split of data will
@@ -1005,25 +999,22 @@ def split(self, train = None, val = None, test = None, shuffle = True):
         # parent loader to be also applied to all the child split loaders
         # until they are actually accessed in this overhead multi-dataset
         # loader class. Then, they will be unset and created.
-        self._loaders.apply(
-            lambda x: x.split(
-                train = train, val = val, test = test, shuffle = shuffle))
+        self._loaders.apply(lambda x: x.split(train=train, val=val, test=test, shuffle=shuffle))
 
         # However, since we are only working off of the accessed data splits
         # for all the sub-loaders, this wrapper loader would otherwise not retain
         # the raw split content (e.g., the `_{train/val/test}_content` attribute
         # for all of the sub-loaders). So, we store this content in the wrapper
         # loader itself, such that it can be accessed later.
-        self._train_content = self._loaders.get_attributes('_train_content', include_names=True)
-        self._val_content = self._loaders.get_attributes('_val_content', include_names=True)
-        self._test_content = self._loaders.get_attributes('_test_content', include_names=True)
+        self._train_content = self._loaders.get_attributes("_train_content", include_names=True)
+        self._val_content = self._loaders.get_attributes("_val_content", include_names=True)
+        self._test_content = self._loaders.get_attributes("_test_content", include_names=True)
 
     def _is_split_generated(self):
         """Check if a data split has been generated (not necessarily accessed)"""
-        return all(i is not None for i in [
-            self._train_content, self._val_content, self._test_content])
+        return all(i is not None for i in [self._train_content, self._val_content, self._test_content])
 
-    def save_split(self, name, overwrite = False):
+    def save_split(self, name, overwrite=False):
         """Saves the current split of data to an internal location.
 
         This method can be used to save the current split of data to an
@@ -1041,34 +1032,35 @@ def save_split(self, name, overwrite = False):
             Whether to overwrite an existing split with the same name.
         """
         # Get the train/val/test splits for each of the sub-loaders.
-        ds_names = self._loaders.get_attributes('name')
-        train_splits = self._loaders.get_attributes('_train_content')
-        val_splits = self._loaders.get_attributes('_val_content')
-        test_splits = self._loaders.get_attributes('_test_content')
+        ds_names = self._loaders.get_attributes("name")
+        train_splits = self._loaders.get_attributes("_train_content")
+        val_splits = self._loaders.get_attributes("_val_content")
+        test_splits = self._loaders.get_attributes("_test_content")
 
         # Check that there is split data.
         if (
-                all(i is None for i in train_splits)
-                and all(i is None for i in val_splits)
-                and all(i is None for i in test_splits)
+            all(i is None for i in train_splits)
+            and all(i is None for i in val_splits)
+            and all(i is None for i in test_splits)
         ):
-            raise ValueError(
-                f"Cannot save a split when no split has been created.")
+            raise ValueError(f"Cannot save a split when no split has been created.")
 
         # Remap the dictionary such that there is a train/val/test dict for each dataset.
-        split_data = {name: {
-            'train': train_splits[i],
-            'val': val_splits[i],
-            'test': test_splits[i]
-        } for i, name in enumerate(ds_names)}
+        split_data = {
+            name: {
+                "train": train_splits[i],
+                "val": val_splits[i],
+                "test": test_splits[i],
+            }
+            for i, name in enumerate(ds_names)
+        }
 
         # Save the split data.
-        split_dir = os.path.join(SUPER_BASE_DIR, 'splits', self.name)
-        os.makedirs(split_dir, exist_ok = True)
-        if os.path.exists(os.path.join(split_dir, f'{name}.json')) and not overwrite:
-            raise FileExistsError(f"Split with name {name} already exists. "
-                                  f"Set `overwrite = True` to overwrite it.")
-        with open(os.path.join(split_dir, f'{name}.json'), 'w') as f:
+        split_dir = os.path.join(SUPER_BASE_DIR, "splits", self.name)
+        os.makedirs(split_dir, exist_ok=True)
+        if os.path.exists(os.path.join(split_dir, f"{name}.json")) and not overwrite:
+            raise FileExistsError(f"Split with name {name} already exists. " f"Set `overwrite = True` to overwrite it.")
+        with open(os.path.join(split_dir, f"{name}.json"), "w") as f:
             json.dump(split_data, f)
 
     def load_split(self, name):
@@ -1088,19 +1080,19 @@ def load_split(self, name):
             the split to load.
         """
         # Ensure that the split exists.
-        split_dir = os.path.join(SUPER_BASE_DIR, 'splits', self.name)
-        if not os.path.exists(os.path.join(split_dir, f'{name}.json')):
+        split_dir = os.path.join(SUPER_BASE_DIR, "splits", self.name)
+        if not os.path.exists(os.path.join(split_dir, f"{name}.json")):
             raise FileNotFoundError(f"Could not find a split with the name {name}.")
 
         # Load the split from the internal location.
-        with open(os.path.join(split_dir, f'{name}.json'), 'r') as f:
+        with open(os.path.join(split_dir, f"{name}.json"), "r") as f:
             all_splits = json.load(f)
 
         # Set the split contents.
         for ds_name, splits in all_splits.items():
-            self._loaders[ds_name].load_split(None, manual_split_set = splits)
+            self._loaders[ds_name].load_split(None, manual_split_set=splits)
 
-    def batch(self, batch_size = None):
+    def batch(self, batch_size=None):
         """Batches sets of image and annotation data according to a size.
 
         This method will group sets of data together into batches of size
@@ -1150,23 +1142,23 @@ def batch(self, batch_size = None):
         overflow = len(self._loader_accessors) - num_splits * batch_size
         extra_items = data_items[-overflow:]
         try:
-            batches = np.array_split(
-                np.array(self._loader_accessors
-                         [:num_splits * batch_size]), num_splits)
+            batches = np.array_split(np.array(self._loader_accessors[: num_splits * batch_size]), num_splits)
         except ValueError:
-            log(f"There is less data ({len(self._loader_accessors)}) than the provided "
-                f"batch size ({batch_size}). Consider using a smaller batch size.")
+            log(
+                f"There is less data ({len(self._loader_accessors)}) than the provided "
+                f"batch size ({batch_size}). Consider using a smaller batch size."
+            )
             batches = [self._loader_accessors]
         else:
             if len(extra_items) < batch_size:
                 batches.append(extra_items)
-        self._loader_accessors = np.array(batches, dtype = object)
+        self._loader_accessors = np.array(batches, dtype=object)
         self._batch_size = batch_size
 
         # Update the batch creation method.
         self._make_batch = self._loaders[0]._manager._train_manager.make_batch
 
-    def resize_images(self, image_size = None, method = 'bilinear'):
+    def resize_images(self, image_size=None, method="bilinear"):
         """Resizes images within the loader to a specified size.
 
         This method applies a resizing parameter for images before they are
@@ -1207,20 +1199,20 @@ def resize_images(self, image_size = None, method = 'bilinear'):
         - If a transform pipeline is provided, images will be resized
           *before* being passed into the transform pipeline.
         """
-        if image_size == 'auto':
-            log("There is no `auto` parameter for resizing images when using"
-                "multiple datasets in a loader. Switching to `default`.")
-
-        self._loaders.apply(
-            lambda x: x.resize_images(
-                image_size = image_size, method = method
+        if image_size == "auto":
+            log(
+                "There is no `auto` parameter for resizing images when using"
+                "multiple datasets in a loader. Switching to `default`."
             )
-        )
 
-    def transform(self,
-                  transform = NoArgument,
-                  target_transform = NoArgument,
-                  dual_transform = NoArgument):
+        self._loaders.apply(lambda x: x.resize_images(image_size=image_size, method=method))
+
+    def transform(
+        self,
+        transform=NoArgument,
+        target_transform=NoArgument,
+        dual_transform=NoArgument,
+    ):
         """Applies vision transforms to the input image and annotation data.
 
         This method applies transformations to the image and annotation data
@@ -1289,13 +1281,13 @@ def transform(self,
         """
         self._loaders.apply(
             lambda x: x._manager.push_transforms(
-                transform = transform,
-                target_transform = target_transform,
-                dual_transform = dual_transform
+                transform=transform,
+                target_transform=target_transform,
+                dual_transform=dual_transform,
             )
         )
 
-    def normalize_images(self, method = 'scale'):
+    def normalize_images(self, method="scale"):
         """Converts images from 0-255 integers to 0-1 floats and normalizes.
 
         This is a convenience method to convert all images from integer-valued
@@ -1329,14 +1321,14 @@ def normalize_images(self, method = 'scale'):
         This method is not implicitly called when converting to PyTorch/TensorFlow
         mode, it needs to be manually called even if you just want 0-1 scaled images.
         """
-        if method not in ['scale', 'imagenet', 'standard', None]:
+        if method not in ["scale", "imagenet", "standard", None]:
             raise ValueError(f"Received invalid normalization method: '{method}'.")
 
-        if method == 'scale':
-            normalization_params = 'scale'
-        elif method == 'imagenet':
-            normalization_params = 'imagenet'
-        elif method == 'standard':
+        if method == "scale":
+            normalization_params = "scale"
+        elif method == "imagenet":
+            normalization_params = "imagenet"
+        elif method == "standard":
             normalization_params = self._info.image_stats
         else:
             normalization_params = None
@@ -1345,11 +1337,11 @@ def normalize_images(self, method = 'scale'):
         # the loader, so we need to make sure we account for this.
         self._loaders.apply(
             lambda x, transform: x._manager.push_transforms(
-                transform = transform,
-                target_transform = NoArgument,
-                dual_transform = NoArgument),
-            args = [('normalize', normalization_params[key])
-                    for key in self._loaders.keys]
+                transform=transform,
+                target_transform=NoArgument,
+                dual_transform=NoArgument,
+            ),
+            args=[("normalize", normalization_params[key]) for key in self._loaders.keys],
         )
 
     def labels_to_one_hot(self):
@@ -1360,13 +1352,10 @@ def labels_to_one_hot(self):
         a set of labels, [1, 2], it will convert it to [[0, 1, 0], [0, 0, 1]].
         This is a more commonly used format for image classification.
         """
-        if self.task != 'image_classification':
-            raise RuntimeError("The `one_hot` label transformation can only "
-                               "be used for image classification tasks.")
+        if self.task != "image_classification":
+            raise RuntimeError("The `one_hot` label transformation can only " "be used for image classification tasks.")
 
-        self.transform(
-            target_transform = ('one_hot', self.num_classes)
-        )
+        self.transform(target_transform=("one_hot", self.num_classes))
 
     def mask_to_channel_basis(self):
         """Converts semantic segmentation masks to channel-wise.
@@ -1380,13 +1369,12 @@ def mask_to_channel_basis(self):
         This method should traditionally be called *after* applying general
         transformations to the loader, in order to prevent any issues.
         """
-        if self.task != 'semantic_segmentation':
-            raise ValueError("The `mask_to_channel_basis` transformation "
-                             "can only be used for semantic segmentation tasks.")
+        if self.task != "semantic_segmentation":
+            raise ValueError(
+                "The `mask_to_channel_basis` transformation " "can only be used for semantic segmentation tasks."
+            )
 
-        self.transform(
-            target_transform = ('channel_basis', self._info.num_classes)
-        )
+        self.transform(target_transform=("channel_basis", self._info.num_classes))
 
     def generalize_class_detections(self):
         """Generalizes object detection classes to a single class.
@@ -1397,17 +1385,23 @@ def generalize_class_detections(self):
         focus on detection of objects and fine-tuning bounding boxes,
         with no focus on differentiating classes of different boxes.
         """
-        if self.task != 'object_detection':
-            raise ValueError("The `generalize_class_detections` transformation"
-                             "can only be used for object detection tasks.")
+        if self.task != "object_detection":
+            raise ValueError(
+                "The `generalize_class_detections` transformation" "can only be used for object detection tasks."
+            )
 
         self._loaders.apply(
             lambda x: x._manager._train_manager._set_annotation_remap_hook(
                 AnnotationRemap(
-                    self.class_to_num, self._info.num_to_class,
-                    self.task, generalize_class_detections = True)))
+                    self.class_to_num,
+                    self._info.num_to_class,
+                    self.task,
+                    generalize_class_detections=True,
+                )
+            )
+        )
 
-    def export_contents(self, export_format = None):
+    def export_contents(self, export_format=None):
         """Exports the internal contents of the `AgMLDataLoader`s.
 
         This method serves as a hook for high-level users who simply want
@@ -1438,11 +1432,7 @@ def export_contents(self, export_format = None):
         -------
         The raw contents of the datasets.
         """
-        return {
-            k: self._loaders[k].export_contents(
-                export_format = export_format)
-            for k in self._loaders.keys
-        }
+        return {k: self._loaders[k].export_contents(export_format=export_format) for k in self._loaders.keys}
 
     @staticmethod
     def _calculate_data_and_loader_index(index, bound_map, set_map):
@@ -1451,9 +1441,9 @@ def _calculate_data_and_loader_index(index, bound_map, set_map):
         if is_equal.size != 0:
             data_idx = 0
         else:
-            data_idx = int(index - list(bound_map.values())[int(
-                np.searchsorted(np.array(
-                    list(bound_map.values())), index) - 1)])
+            data_idx = int(
+                index - list(bound_map.values())[int(np.searchsorted(np.array(list(bound_map.values())), index) - 1)]
+            )
         if data_idx < 0:
             data_idx = 0
         return loader_idx, data_idx
@@ -1461,8 +1451,7 @@ def _calculate_data_and_loader_index(index, bound_map, set_map):
     def _load_one_image_and_annotation(self, index):
         """Loads one image and annotation from a `DataObject`."""
         # Get the image and annotation from the corresponding loader.
-        loader, data_idx = self._calculate_data_and_loader_index(
-            index, self._bounds, self._set_to_keys)
+        loader, data_idx = self._calculate_data_and_loader_index(index, self._bounds, self._set_to_keys)
         return self._loaders[loader][data_idx]
 
     def _load_multiple_items(self, indexes):
@@ -1474,8 +1463,7 @@ def _load_multiple_items(self, indexes):
                 contents.append(self._load_batch(self._loader_accessors[i]))
         else:
             for i in indexes:
-                contents.append(self._load_one_image_and_annotation(
-                    self._loader_accessors[i]))
+                contents.append(self._load_one_image_and_annotation(self._loader_accessors[i]))
         return contents
 
     def _batch_multi_image_inputs(self, images):
@@ -1495,17 +1483,19 @@ def _batch_multi_image_inputs(self, images):
     def _batch_multi_output_annotations(self, annotations):
         """Converts either a list of annotations or multiple annotation types into a batch."""
         # If the output annotations are simple objects.
-        if (isinstance(annotations[0], (list, np.ndarray))
+        if (
+            isinstance(annotations[0], (list, np.ndarray))
             or isinstance(annotations, (list, np.ndarray))
-                and isinstance(annotations[0], (int, float))):
+            and isinstance(annotations[0], (int, float))
+        ):
             if not consistent_shapes(annotations):
-                annotations = np.array(annotations, dtype = object)
+                annotations = np.array(annotations, dtype=object)
             else:
                 annotations = np.array(annotations)
             return annotations
 
         # For object detection, just return the COCO JSON dictionaries.
-        if self.task == 'object_detection':
+        if self.task == "object_detection":
             return annotations
 
         # Otherwise, convert all of them independently.
@@ -1540,10 +1530,7 @@ def _load_batch(self, batch_indexes):
         annotations = self._batch_multi_output_annotations(annotations)
 
         # Return the batches.
-        return self._make_batch(
-            images = images,
-            annotations = annotations
-        )
+        return self._make_batch(images=images, annotations=annotations)
 
     def _get_item_impl(self, indexes):
         """Loads and processes a piece (or pieces) of data from the dataset.
@@ -1556,8 +1543,7 @@ def _get_item_impl(self, indexes):
         # If there is only one index and the data is not batched,
         # then we just need to return a single `DataObject`.
         if isinstance(indexes, int) and self._batch_size is None:
-            return self._load_one_image_and_annotation(
-                self._loader_accessors[indexes])
+            return self._load_one_image_and_annotation(self._loader_accessors[indexes])
 
         # If we have a batch of images, then return the batch.
         if isinstance(indexes, int) and self._batch_size is not None:
@@ -1597,13 +1583,14 @@ def export_torch(self, **loader_kwargs):
         -------
         A `torch.utils.data.DataLoader` enclosing a copy of this loader.
         """
-        from agml.backend.tftorch import torch
         from torch.utils.data import DataLoader
-        if get_backend() != 'torch':
+
+        from agml.backend.tftorch import torch
+
+        if get_backend() != "torch":
             if user_changed_backend():
-                raise StrictBackendError(
-                    change = 'torch', obj = self.export_torch)
-            set_backend('torch')
+                raise StrictBackendError(change="torch", obj=self.export_torch)
+            set_backend("torch")
 
         # Make a copy of the `AgMLDataLoader` so the following changes
         # don't affect the original loader, just the new one.
@@ -1614,20 +1601,18 @@ def export_torch(self, **loader_kwargs):
 
         # The `DataLoader` automatically batches objects using its
         # own mechanism, so we remove batching from this DataLoader.
-        batch_size = loader_kwargs.pop(
-            'batch_size', obj._batch_size)
+        batch_size = loader_kwargs.pop("batch_size", obj._batch_size)
         obj.batch(None)
-        shuffle = loader_kwargs.pop(
-            'shuffle', obj._shuffle_data)
+        shuffle = loader_kwargs.pop("shuffle", obj._shuffle_data)
 
         # The `collate_fn` for object detection is different because
         # the COCO JSON dictionaries each have different formats. So,
         # we need to replace it with a custom function.
-        collate_fn = loader_kwargs.pop('collate_fn')
-        if obj.task == 'object_detection' and collate_fn is None:
+        collate_fn = loader_kwargs.pop("collate_fn")
+        if obj.task == "object_detection" and collate_fn is None:
+
             def collate_fn(batch):
-                images = torch.stack(
-                    [i[0] for i in batch], dim = 0)
+                images = torch.stack([i[0] for i in batch], dim=0)
                 coco = tuple([i[1] for i in batch])
                 return images, coco
 
@@ -1635,10 +1620,10 @@ def collate_fn(batch):
         # that changes to this will not affect the returned loader.
         return DataLoader(
             obj,
-            batch_size = batch_size,
-            shuffle = shuffle,
-            collate_fn = collate_fn,
-            **loader_kwargs
+            batch_size=batch_size,
+            shuffle=shuffle,
+            collate_fn=collate_fn,
+            **loader_kwargs,
         )
 
     def export_tensorflow(self, **loader_kwargs):
@@ -1670,11 +1655,11 @@ def export_tensorflow(self, **loader_kwargs):
         A `tf.data.Dataset` enclosing a copy of this loader.
         """
         from agml.backend.tftorch import tf
-        if get_backend() != 'tensorflow':
+
+        if get_backend() != "tensorflow":
             if user_changed_backend():
-                raise StrictBackendError(
-                    change = 'tensorflow', obj = self.export_tensorflow)
-            set_backend('tensorflow')
+                raise StrictBackendError(change="tensorflow", obj=self.export_tensorflow)
+            set_backend("tensorflow")
 
         # Make a copy of the `AgMLDataLoader` so the following changes
         # don't affect the original loader, just the new one.
@@ -1685,20 +1670,18 @@ def export_tensorflow(self, **loader_kwargs):
 
         # The `tf.data.Dataset` automatically batches objects using its
         # own mechanism, so we remove batching from this DataLoader.
-        batch_size = loader_kwargs.pop(
-            'batch_size', obj._batch_size)
+        batch_size = loader_kwargs.pop("batch_size", obj._batch_size)
         obj.batch(None)
-        shuffle = loader_kwargs.pop(
-            'shuffle', obj._shuffle_data)
+        shuffle = loader_kwargs.pop("shuffle", obj._shuffle_data)
 
         # Return the DataLoader with a copy of this AgMLDataLoader, so
         # that changes to this will not affect the returned loader.
         return tf.data.Dataset.from_generator(
             obj,
-            output_signature = obj._output_signature,
-            batch_size = batch_size,
-            shuffle = shuffle,
-            **loader_kwargs
+            output_signature=obj._output_signature,
+            batch_size=batch_size,
+            shuffle=shuffle,
+            **loader_kwargs,
         )
 
     def export_yolo(self, yolo_path=None):
@@ -1718,9 +1701,8 @@ def export_yolo(self, yolo_path=None):
         -------
         The path to the saved YOLO-formatted dataset.
         """
-        if self._info.tasks.ml != 'object_detection':
-            raise ValueError("The `export_yolo` method can only be used for "
-                             "object detection tasks.")
+        if self._info.tasks.ml != "object_detection":
+            raise ValueError("The `export_yolo` method can only be used for " "object detection tasks.")
         return export_yolo(self, yolo_path=yolo_path)
 
     def show_sample(self, image_only=False, no_show=False):
@@ -1752,12 +1734,10 @@ def show_sample(self, image_only=False, no_show=False):
             annotations = annotations[0]
 
         # Show the sample.
-        show_sample(self,
-                    image_only=image_only,
-                    no_show=no_show,
-                    sample=(image, annotations),
-                    num_to_class=self.num_to_class)
-
-
-
-
+        show_sample(
+            self,
+            image_only=image_only,
+            no_show=no_show,
+            sample=(image, annotations),
+            num_to_class=self.num_to_class,
+        )
diff --git a/agml/data/object.py b/agml/data/object.py
index 9ea39d12..92c39eee 100644
--- a/agml/data/object.py
+++ b/agml/data/object.py
@@ -12,16 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import abc
+import os
 from functools import wraps
 
 import cv2
 import numpy as np
 
+from agml.backend.tftorch import scalar_unpack
 from agml.framework import AgMLSerializable
 from agml.utils.image import imread_context
-from agml.backend.tftorch import scalar_unpack
 
 
 class DataObject(AgMLSerializable):
@@ -38,9 +38,9 @@ class DataObject(AgMLSerializable):
     `AgMLDataLoader`, and objects returned from it are returned as their
     expected contents (NumPy arrays/dictionaries/integers) when necessary.
     """
-    serializable = frozenset(
-        ('image_object', 'annotation_obj', 'dataset_root'))
-    _abstract = frozenset(('_load_image_input', '_parse_annotation'))
+
+    serializable = frozenset(("image_object", "annotation_obj", "dataset_root"))
+    _abstract = frozenset(("_load_image_input", "_parse_annotation"))
 
     def __init__(self, image, annotation, root):
         # The `image` parameter is constant among different tasks.
@@ -70,12 +70,12 @@ def _parse_image(path):
 
     @staticmethod
     def _parse_depth_image(path):
-        with imread_context(os.path.abspath(path), flags = -1) as image:
+        with imread_context(os.path.abspath(path), flags=-1) as image:
             return image.astype(np.int32)
 
     @staticmethod
     def _parse_spectral_image(path):
-        None # noqa, prevents `all abstract methods must be implemented`
+        None  # noqa, prevents `all abstract methods must be implemented`
         raise NotImplementedError("Multi/Hyperspectral images are not yet supported.")
 
     def get(self):
@@ -97,24 +97,24 @@ def __init_subclass__(cls, **kwargs):
         # docstring from this `DataObject` class and updates
         # the derived class' dictionary.
         wrapped_updates = {}
-        self = super(DataObject, cls).__thisclass__ # noqa
+        self = super(DataObject, cls).__thisclass__  # noqa
         for name, method in cls.__dict__.items():
             if name in cls._abstract:
                 wrapped = wraps(getattr(self, name))(method)
                 wrapped_updates[name] = wrapped
-        for name, method in wrapped_updates.items(): # noqa
+        for name, method in wrapped_updates.items():  # noqa
             setattr(cls, name, method)
 
     @staticmethod
     def create(contents, task, root):
         """Creates a new `DataObject` for the corresponding task."""
-        if task == 'image_classification':
+        if task == "image_classification":
             cls = ImageClassificationDataObject
-        elif task == 'image_regression':
+        elif task == "image_regression":
             cls = ImageRegressionDataObject
-        elif task == 'object_detection':
+        elif task == "object_detection":
             cls = ObjectDetectionDataObject
-        elif task == 'semantic_segmentation':
+        elif task == "semantic_segmentation":
             cls = SemanticSegmentationDataObject
         else:
             raise ValueError(f"Unsupported task {task}.")
@@ -142,31 +142,39 @@ def _parse_label(obj):
         try:
             obj = int(obj)
         except TypeError:
-            raise Exception(f"Could not convert object {obj} of "
-                            f"type {type(obj)} to a scalar integer "
-                            f"for image classification.")
+            raise Exception(
+                f"Could not convert object {obj} of "
+                f"type {type(obj)} to a scalar integer "
+                f"for image classification."
+            )
         return obj
 
     @staticmethod
     def _parse_coco(obj):
         """Parses a COCO JSON dictionary for an object detection task."""
-        annotation = {'bbox': [], 'category_id': [], 'area': [],
-                      'image_id': "", 'iscrowd': [], 'segmentation': []}
+        annotation = {
+            "bbox": [],
+            "category_id": [],
+            "area": [],
+            "image_id": "",
+            "iscrowd": [],
+            "segmentation": [],
+        }
         for a_set in obj:
-            x, y, w, h = a_set['bbox']
+            x, y, w, h = a_set["bbox"]
             x = int(np.clip(x, 0, None))
             y = int(np.clip(y, 0, None))
-            a_set['bbox'] = [x, y, w, h]
-            annotation['bbox'].append(a_set['bbox'])
-            annotation['category_id'].append(a_set['category_id'])
-            annotation['iscrowd'].append(a_set['iscrowd'])
-            annotation['segmentation'].append(a_set['segmentation'])
-            annotation['area'].append(a_set['area'])
-            annotation['image_id'] = a_set['image_id']
+            a_set["bbox"] = [x, y, w, h]
+            annotation["bbox"].append(a_set["bbox"])
+            annotation["category_id"].append(a_set["category_id"])
+            annotation["iscrowd"].append(a_set["iscrowd"])
+            annotation["segmentation"].append(a_set["segmentation"])
+            annotation["area"].append(a_set["area"])
+            annotation["image_id"] = a_set["image_id"]
         for key, value in annotation.items():
             # Creating nested sequences from ragged arrays (see numpy).
-            if key in ['segmentation']:
-                out = np.array(value, dtype = object)
+            if key in ["segmentation"]:
+                out = np.array(value, dtype=object)
             else:
                 out = np.array(value)
                 if np.isscalar(out):
@@ -180,14 +188,14 @@ def _parse_mask(obj):
         with imread_context(os.path.realpath(obj)) as image:
             if image.ndim == 3:
                 if not np.all(image[:, :, 0] == image[:, :, 1]):
-                    raise TypeError(
-                        f"Invalid annotation mask of shape {image.shape}.")
+                    raise TypeError(f"Invalid annotation mask of shape {image.shape}.")
                 image = image[:, :, 0]
             return np.squeeze(image)
 
 
 class ImageClassificationDataObject(DataObject):
     """Serves as a `DataObject` for image classification tasks."""
+
     def _load_image_input(self, path):
         return self._parse_image(path)
 
@@ -197,6 +205,7 @@ def _parse_annotation(self, obj):
 
 class ImageRegressionDataObject(DataObject):
     """Serves as a `DataObject` for image regression tasks."""
+
     def _load_image_input(self, contents):
         # The easy case, when there is only one input image.
         if isinstance(contents, str) and os.path.exists(contents):
@@ -206,9 +215,9 @@ def _load_image_input(self, contents):
         # input types, so we need to independently load those.
         images = dict.fromkeys(contents.keys(), None)
         for c_type, path in contents.items():
-            if c_type == 'image':
+            if c_type == "image":
                 images[c_type] = self._parse_image(path)
-            elif c_type == 'depth_image':
+            elif c_type == "depth_image":
                 images[c_type] = self._parse_depth_image(path)
             else:
                 images[c_type] = self._parse_spectral_image(path)
@@ -220,8 +229,9 @@ def _parse_annotation(self, obj):
 
 class ObjectDetectionDataObject(DataObject):
     """Serves as a `DataObject` from object detection tasks."""
+
     def _load_image_input(self, path):
-        path = os.path.join(self._dataset_root, 'images', path)
+        path = os.path.join(self._dataset_root, "images", path)
         return self._parse_image(path)
 
     def _parse_annotation(self, obj):
@@ -230,11 +240,9 @@ def _parse_annotation(self, obj):
 
 class SemanticSegmentationDataObject(DataObject):
     """Serves as a `DataObject` for semantic segmentation tasks."""
+
     def _load_image_input(self, path):
         return self._parse_image(path)
 
     def _parse_annotation(self, obj):
         return self._parse_mask(obj)
-
-
-
diff --git a/agml/data/point_cloud.py b/agml/data/point_cloud.py
index 16ae4273..3ac6679e 100644
--- a/agml/data/point_cloud.py
+++ b/agml/data/point_cloud.py
@@ -15,7 +15,6 @@
 import os
 
 import numpy as np
-
 from matplotlib.pyplot import cm
 
 from agml.utils.general import is_float, is_int
@@ -26,31 +25,35 @@ class PointCloud(object):
     """Represents a 3D point cloud object, with utilities for format + visualization."""
 
     # Valid structures for the point cloud file.
-    VALID_STRUCTURES = {'x': float,
-                        'y': float,
-                        'z': float,
-                        'label': int,
-                        'intensity': float,
-                        'r': int,
-                        'g': float,
-                        'b': float}
+    VALID_STRUCTURES = {
+        "x": float,
+        "y": float,
+        "z": float,
+        "label": int,
+        "intensity": float,
+        "r": int,
+        "g": float,
+        "b": float,
+    }
 
     # Mapping between string labels and their integer representation.
-    LABEL_MAPPING = {'none': -9999,
-                     'ground': 1,
-                     'trunk': 2,
-                     'shoot': 3,
-                     'leaf': 4,
-                     'fruit': 5}
-
-    def __init__(self, contents, structure = None, colormap = None):
+    LABEL_MAPPING = {
+        "none": -9999,
+        "ground": 1,
+        "trunk": 2,
+        "shoot": 3,
+        "leaf": 4,
+        "fruit": 5,
+    }
+
+    def __init__(self, contents, structure=None, colormap=None):
         # `contents` is expected to be the path to a point cloud `xyz` file, but can
         # also be the contents of the file itself, in which case there is not saved path.
         if isinstance(contents, str):
             contents = os.path.abspath(contents)
             if not os.path.exists(contents):
-                raise FileNotFoundError(f'Point cloud file {contents} does not exist.')
-            raw_contents = [i for i in open(contents, 'r').read().splitlines() if not i == '']
+                raise FileNotFoundError(f"Point cloud file {contents} does not exist.")
+            raw_contents = [i for i in open(contents, "r").read().splitlines() if not i == ""]
             self._raw_contents = raw_contents
             self._path = contents
         else:
@@ -93,55 +96,69 @@ def _infer_structure(row, pointcloud_structure):
         if pointcloud_structure is not None:
             # If a string is passed, it should contain space/comma separated values.
             if isinstance(pointcloud_structure, str):
-                if ',' in pointcloud_structure:
-                    pointcloud_structure = [i.strip() for i in pointcloud_structure.split(',')]
+                if "," in pointcloud_structure:
+                    pointcloud_structure = [i.strip() for i in pointcloud_structure.split(",")]
                 else:
-                    pointcloud_structure = pointcloud_structure.split(' ')
+                    pointcloud_structure = pointcloud_structure.split(" ")
 
             # If a list is passed, it should contain only strings.
             elif isinstance(pointcloud_structure, list):
                 if not all(isinstance(i, str) for i in pointcloud_structure):
-                    raise TypeError('Point cloud structure must be a list of strings.')
+                    raise TypeError("Point cloud structure must be a list of strings.")
 
             # Check that each of the structural values is valid.
             if not all(i in PointCloud.VALID_STRUCTURES for i in pointcloud_structure):
-                raise ValueError(f'Invalid point cloud structure {pointcloud_structure}, '
-                                 f'should only contain values in {PointCloud.VALID_STRUCTURES.keys()}.')
+                raise ValueError(
+                    f"Invalid point cloud structure {pointcloud_structure}, "
+                    f"should only contain values in {PointCloud.VALID_STRUCTURES.keys()}."
+                )
 
         # If no structure is passed, check if it fits one of the common formats.
         else:
             # Preprocess the row.
-            row = row.strip().split(' ')
+            row = row.strip().split(" ")
 
             # Three float values is `x y z` format.
             if len(row) == 3:
                 if all(is_float(i) for i in row):
-                    pointcloud_structure = ['x', 'y', 'z']
+                    pointcloud_structure = ["x", "y", "z"]
 
             # Three float values and one integer value is `x y z label` format.
             elif len(row) == 4:
                 if all(is_float(i) for i in row[:-1]) and is_int(row[-1]):
-                    pointcloud_structure = ['x', 'y', 'z', 'label']
+                    pointcloud_structure = ["x", "y", "z", "label"]
 
             # Eight values (three float, an integer, and four floats) is the
             # complete `x y z label intensity r g b` format.
             elif len(row) == 8:
-                if (all(is_float(i) for i in row[:-4])
-                        and all(is_int(i) for i in row[3:-1])
-                        and all(is_float(i) for i in row[-4:])):
-                    pointcloud_structure = ['x', 'y', 'z', 'label', 'intensity', 'r', 'g', 'b']
+                if (
+                    all(is_float(i) for i in row[:-4])
+                    and all(is_int(i) for i in row[3:-1])
+                    and all(is_float(i) for i in row[-4:])
+                ):
+                    pointcloud_structure = [
+                        "x",
+                        "y",
+                        "z",
+                        "label",
+                        "intensity",
+                        "r",
+                        "g",
+                        "b",
+                    ]
 
             # Otherwise, we have encountered some form of format that we do not support.
             else:
-                raise ValueError('Could not infer point cloud structure from file.')
+                raise ValueError("Could not infer point cloud structure from file.")
 
         # Check that the point cloud structure makes sense (e.g., at minimum it
         # should have `x y z`, and it shouldn't just have `r` and not `g b`, etc).
-        if any(i not in pointcloud_structure for i in ['x', 'y', 'z']):
-            raise ValueError('Point cloud structure must contain `x y z`.')
-        if any(i in pointcloud_structure for i in ['r', 'g', 'b']) \
-                and not all(i in pointcloud_structure for i in ['r', 'g', 'b']):
-            raise ValueError('Point cloud structure must contain all of `r g b`.')
+        if any(i not in pointcloud_structure for i in ["x", "y", "z"]):
+            raise ValueError("Point cloud structure must contain `x y z`.")
+        if any(i in pointcloud_structure for i in ["r", "g", "b"]) and not all(
+            i in pointcloud_structure for i in ["r", "g", "b"]
+        ):
+            raise ValueError("Point cloud structure must contain all of `r g b`.")
 
         return pointcloud_structure
 
@@ -153,34 +170,34 @@ def _read_point_cloud(self, contents):
         """Reads the contents of the point cloud file with the given structure."""
         full_data = []
         for line in contents:
-            line = line.strip().split(' ')
-            current_line = [PointCloud.VALID_STRUCTURES[fmt](i)
-                            for i, fmt in zip(line, self._structure)]
-            current_line = [i if i != -9999 else 0 for i in current_line] # fix this label
+            line = line.strip().split(" ")
+            current_line = [PointCloud.VALID_STRUCTURES[fmt](i) for i, fmt in zip(line, self._structure)]
+            current_line = [i if i != -9999 else 0 for i in current_line]  # fix this label
             full_data.append(current_line)
 
         # Create arrays with the data.
-        xyz_indices = [self._structure.index(c) for c in ['x', 'y', 'z']]
+        xyz_indices = [self._structure.index(c) for c in ["x", "y", "z"]]
         self._coordinates = np.array(full_data)[:, xyz_indices]
         self._full_data = np.array(full_data)
 
         # Load the corresponding colormap for the coordinates if possible.
-        if 'label' in self._structure:
-            self._labels = labels = self._full_data[:, self._structure.index('label')].astype(int)
+        if "label" in self._structure:
+            self._labels = labels = self._full_data[:, self._structure.index("label")].astype(int)
         else:
-            labels = np.zeros(shape = (len(full_data),), dtype = int)
+            labels = np.zeros(shape=(len(full_data),), dtype=int)
             self._labels = None
         self._pointcloud_colors = [self._colormap[i][:3] for i in labels]
 
     def _build_3d_object(self):
-        """Function to construct the point cloud as a open3d point cloud object
-        """
+        """Function to construct the point cloud as a open3d point cloud object"""
         try:
             import open3d as o3d
         except:
-            log("Open3D is not installed. If you want to have high-res point cloud "
+            log(
+                "Open3D is not installed. If you want to have high-res point cloud "
                 "visualizations, please install Open3D using `pip install open3d`. "
-                "For now, defaulting to using 3D matplotlib visualizations.")
+                "For now, defaulting to using 3D matplotlib visualizations."
+            )
             o3d = None
 
         # Construct the point cloud with the points and colors.
@@ -195,9 +212,9 @@ def _build_3d_object(self):
         else:
             self._structure_3d = None
 
-    def show(self, format = 'default'):
+    def show(self, format="default"):
         """Show a point cloud sample with its labels."""
         # Prevent circular imports.
         from agml.viz.point_clouds import show_point_cloud
-        show_point_cloud(self, format = format)
 
+        show_point_cloud(self, format=format)
diff --git a/agml/data/public.py b/agml/data/public.py
index 911627fc..9ee13f59 100644
--- a/agml/data/public.py
+++ b/agml/data/public.py
@@ -16,14 +16,15 @@
 
 import numpy as np
 
-from agml.utils.downloads import download_dataset as _download # noqa
-from agml.utils.data import load_public_sources
-from agml.data.metadata import DatasetMetadata
 from agml.backend.config import data_save_path
+from agml.data.metadata import DatasetMetadata
+from agml.utils.data import load_public_sources
+from agml.utils.downloads import download_dataset as _download  # noqa
 
 
 class _PublicSourceFilter(object):
     """Filters public datasets based on the input filters."""
+
     _sources = load_public_sources()
     _current_filtered_source = []
 
@@ -36,56 +37,53 @@ def apply_filters(self, **filters):
             if key not in list(self._sources.values())[0].keys():
                 raise ValueError(f"Invalid filter: {key}.")
             internal_set = []
-            if key == 'location':
+            if key == "location":
                 self._location_case(value, internal_set)
-            elif key in ['n_images', 'num_images'] and value.startswith('>'):
-                self._n_image_case_greater(
-                    int(float(value[1:])), internal_set)
-            elif key in ['n_images', 'num_images'] and value.startswith('<'):
-                self._n_image_case_greater(
-                    int(float(value[1:])), internal_set)
+            elif key in ["n_images", "num_images"] and value.startswith(">"):
+                self._n_image_case_greater(int(float(value[1:])), internal_set)
+            elif key in ["n_images", "num_images"] and value.startswith("<"):
+                self._n_image_case_greater(int(float(value[1:])), internal_set)
             else:
                 for source_ in self._sources.keys():
                     try:
                         if self._sources[source_][key] == value:
                             internal_set.append(source_)
-                    except: # some situations don't have certain arguments.
+                    except:  # some situations don't have certain arguments.
                         continue
             source_sets.append(internal_set)
-        self._current_filtered_source \
-            = functools.reduce(np.intersect1d, source_sets)
+        self._current_filtered_source = functools.reduce(np.intersect1d, source_sets)
         return self
 
     def _location_case(self, desired, value_set):
         for source_ in self._sources.keys():
-            param, value = desired.split(':')
+            param, value = desired.split(":")
             try:
-                if self._sources[source_]['location'][param] == value:
+                if self._sources[source_]["location"][param] == value:
                     value_set.append(source_)
-            except KeyError: # some situations don't have location.
+            except KeyError:  # some situations don't have location.
                 continue
         return value_set
 
     def _n_image_case_greater(self, thresh, value_set):
         for source_ in self._sources.keys():
             try:
-                if int(float(self._sources[source_]['n_images'])) >= thresh:
+                if int(float(self._sources[source_]["n_images"])) >= thresh:
                     value_set.append(source_)
-            except KeyError: # some situations don't have n_images.
+            except KeyError:  # some situations don't have n_images.
                 continue
         return
 
     def _n_image_case_lesser(self, thresh, value_set):
         for source_ in self._sources.keys():
             try:
-                if int(float(self._sources[source_]['n_images'])) <= thresh:
+                if int(float(self._sources[source_]["n_images"])) <= thresh:
                     value_set.append(source_)
-            except KeyError: # some situations don't have n_images.
+            except KeyError:  # some situations don't have n_images.
                 continue
         return
 
     def print_result(self):
-        return "[%s]" % ', '.join(self._current_filtered_source)
+        return "[%s]" % ", ".join(self._current_filtered_source)
 
     def result(self):
         return [DatasetMetadata(s) for s in self._current_filtered_source]
@@ -149,7 +147,7 @@ def source(name):
     return DatasetMetadata(name)
 
 
-def download_public_dataset(dataset, location = None, redownload = False):
+def download_public_dataset(dataset, location=None, redownload=False):
     """Downloads a public dataset from AgML to a directory.
 
     While the `AgMLDataLoader` exists to load data directly into an
@@ -174,12 +172,9 @@ def download_public_dataset(dataset, location = None, redownload = False):
     -------
     The local directory of the dataset.
     """
-    location = location if location \
-                        else data_save_path()
+    location = location if location else data_save_path()
     if not isinstance(dataset, (list, tuple, set, np.ndarray)):
         dataset = [dataset]
     for d in dataset:
-        _download(d, location, redownload = redownload)
+        _download(d, location, redownload=redownload)
     return location
-
-
diff --git a/agml/data/tools.py b/agml/data/tools.py
index 499ed8f4..1d5beaab 100644
--- a/agml/data/tools.py
+++ b/agml/data/tools.py
@@ -31,15 +31,21 @@ def _resolve_coco_annotations(annotations):
             return annotations
         if len(annotations) == 1:
             return annotations
-        annotation = {'bboxes': [], 'labels': [], 'area': [],
-                      'image_id': "", 'iscrowd': [], 'segmentation': []}
+        annotation = {
+            "bboxes": [],
+            "labels": [],
+            "area": [],
+            "image_id": "",
+            "iscrowd": [],
+            "segmentation": [],
+        }
         for a_set in annotations:
-            annotation['bboxes'].append(a_set['bbox'])
-            annotation['labels'].append(a_set['category_id'])
-            annotation['iscrowd'].append(a_set['iscrowd'])
-            annotation['segmentation'].append(a_set['segmentation'])
-            annotation['area'].append(a_set['area'])
-            annotation['image_id'] = a_set['image_id']
+            annotation["bboxes"].append(a_set["bbox"])
+            annotation["labels"].append(a_set["category_id"])
+            annotation["iscrowd"].append(a_set["iscrowd"])
+            annotation["segmentation"].append(a_set["segmentation"])
+            annotation["area"].append(a_set["area"])
+            annotation["image_id"] = a_set["image_id"]
         for key, value in annotation.items():
             out = np.array(value)
             if np.isscalar(out):
@@ -53,9 +59,7 @@ def _resolve_coco_annotations(annotations):
     elif isinstance(annotations, np.ndarray):
         return annotations
     else:
-        raise TypeError(
-            "Expected either a single COCO annotation "
-            "dictionary or a list of multiple dictionaries.")
+        raise TypeError("Expected either a single COCO annotation " "dictionary or a list of multiple dictionaries.")
 
 
 def coco_to_bboxes(annotations):
@@ -76,7 +80,8 @@ def coco_to_bboxes(annotations):
     Two arrays consisting of the bounding boxes and labels.
     """
     annotations = _resolve_coco_annotations(annotations)
-    return annotations['bbox'], annotations['category_id']
+    print(annotations.keys())
+    return annotations["bboxes"], annotations["labels"]
 
 
 def convert_bbox_format(annotations_or_bboxes, fmt):
@@ -117,52 +122,59 @@ def convert_bbox_format(annotations_or_bboxes, fmt):
 
     annotations_or_bboxes = _resolve_coco_annotations(annotations_or_bboxes)
     if isinstance(annotations_or_bboxes, dict):
-        annotations = annotations_or_bboxes['bboxes']
+        annotations = annotations_or_bboxes["bboxes"]
     else:
         annotations = annotations_or_bboxes
         if isinstance(annotations[0], (int, float)):
             annotations = [annotations]
     if isinstance(fmt, str):
-        if 'voc' in fmt or 'pascal' in fmt:
-            fmt = 'x_min y_min x_max y_max'
-        elif 'efficientdet' in fmt or 'effdet' in fmt:
-            fmt = 'y_min x_min y_max x_max'
-        if fmt == 'xyxy':
-            fmt = 'x_min y_min x_max y_max'
-        if fmt == 'yxyx':
-            fmt = 'y_min x_min y_max x_max'
-        if ',' in fmt:
-            fmt = fmt.split(',')
+        if "voc" in fmt or "pascal" in fmt:
+            fmt = "x_min y_min x_max y_max"
+        elif "efficientdet" in fmt or "effdet" in fmt:
+            fmt = "y_min x_min y_max x_max"
+        if fmt == "xyxy":
+            fmt = "x_min y_min x_max y_max"
+        if fmt == "yxyx":
+            fmt = "y_min x_min y_max x_max"
+        if "," in fmt:
+            fmt = fmt.split(",")
         else:
-            fmt = fmt.split(' ')
+            fmt = fmt.split(" ")
     if len(fmt) != 4:
         raise ValueError(f"Argument 'fmt' should contain 4 values, got {len(fmt)}.")
-    
+
     # Define all of the intermediate conversion methods
-    def _x1_x2_y1_y2_to_coco(annotation): # noqa
+    def _x1_x2_y1_y2_to_coco(annotation):  # noqa
         x1, x2, y1, y2 = annotation
         width, height = abs(x2 - x1), abs(y2 - y1)
         return [x1, y1, width, height]
-    def _xmin_ymin_xmax_ymax_to_coco(annotation): # noqa
+
+    def _xmin_ymin_xmax_ymax_to_coco(annotation):  # noqa
         xmin, ymin, xmax, ymax = annotation
         width, height = abs(xmax - xmin), abs(ymax - ymin)
         return [xmin, ymin, width, height]
-    def _xmin_ymin_width_height_to_coco(annotation): # noqa
+
+    def _xmin_ymin_width_height_to_coco(annotation):  # noqa
         xmin, ymin, width, height = annotation
         x1, y1 = xmin, ymin - height
         return [x1, y1, width, height]
-    def _x1_y1_width_height_to_coco(annotation): # noqa
-        return annotation # This is just here for reordering.
+
+    def _x1_y1_width_height_to_coco(annotation):  # noqa
+        return annotation  # This is just here for reordering.
 
     # Resolve the format
-    fmt_bases = [['x1', 'x2', 'y1', 'y2'],
-                 ['x_min', 'y_min', 'x_max', 'y_max'],
-                 ['x_min', 'y_min', 'width', 'height'],
-                 ['x1', 'y1', 'width', 'height']]
-    fmt_map = {0: _x1_x2_y1_y2_to_coco,
-               1: _xmin_ymin_xmax_ymax_to_coco,
-               2: _xmin_ymin_width_height_to_coco,
-               3: _x1_y1_width_height_to_coco}
+    fmt_bases = [
+        ["x1", "x2", "y1", "y2"],
+        ["x_min", "y_min", "x_max", "y_max"],
+        ["x_min", "y_min", "width", "height"],
+        ["x1", "y1", "width", "height"],
+    ]
+    fmt_map = {
+        0: _x1_x2_y1_y2_to_coco,
+        1: _xmin_ymin_xmax_ymax_to_coco,
+        2: _xmin_ymin_width_height_to_coco,
+        3: _x1_y1_width_height_to_coco,
+    }
     fmt_found = False
     map_fmt, select_order = None, None
     for indx, base in enumerate(fmt_bases):
@@ -170,9 +182,7 @@ def _x1_y1_width_height_to_coco(annotation): # noqa
             fmt_found, map_fmt = True, fmt_map[indx]
             select_order = [base.index(i) for i in fmt]
     if not fmt_found:
-        raise ValueError(
-            f"Invalid format {fmt}, see `convert_bbox_format` "
-            f"for information about valid formats.")
+        raise ValueError(f"Invalid format {fmt}, see `convert_bbox_format` " f"for information about valid formats.")
 
     # Convert the formats
     formatted_annotations = []
@@ -182,7 +192,6 @@ def _x1_y1_width_height_to_coco(annotation): # noqa
     formatted_annotations = np.array(formatted_annotations)
     if isinstance(annotations_or_bboxes, dict):
         res = annotations_or_bboxes.copy()
-        res['bboxes'] = formatted_annotations
+        res["bboxes"] = formatted_annotations
         return res
     return resolve_list_value(formatted_annotations)
-
diff --git a/agml/framework.py b/agml/framework.py
index ef442d99..548fc046 100644
--- a/agml/framework.py
+++ b/agml/framework.py
@@ -39,18 +39,19 @@ class AgMLSerializable(object):
     In turn, objects can be used with a JSON serialization format,
     the pickle serialization format, or copied as desired.
     """
+
     serializable: "frozenset"
     state_override: "frozenset"
 
     def __init_subclass__(cls, **kwargs):
-        if not hasattr(cls, 'state_override'):
+        if not hasattr(cls, "state_override"):
             cls.state_override = frozenset(())
 
     def __getstate__(self):
         state = {}
         for param in self.serializable:
             try:
-                state[param] = getattr(self, f'_{param}')
+                state[param] = getattr(self, f"_{param}")
             except AttributeError:
                 if param in self.state_override:
                     state[param] = getattr(self, param)
@@ -58,7 +59,8 @@ def __getstate__(self):
                     raise AttributeError(
                         f"Encountered error while attempting to serialize "
                         f"a {self.__class__}: the attribute '_{param}' "
-                        f"(or '{param}') does not exist.")
+                        f"(or '{param}') does not exist."
+                    )
         return state
 
     def __setstate__(self, state):
@@ -66,9 +68,9 @@ def __setstate__(self, state):
             if field in self.state_override:
                 setattr(self, field, state[field])
             else:
-                setattr(self, f'_{field}', state[field])
+                setattr(self, f"_{field}", state[field])
 
-    def __deepcopy__(self, memo = None):
+    def __deepcopy__(self, memo=None):
         params = self.__getstate__()
         cls = super(AgMLSerializable, self).__new__(self.__class__)
         cls.__setstate__(copy.deepcopy(params))
@@ -76,7 +78,3 @@ def __deepcopy__(self, memo = None):
 
     def __copy__(self):
         return self.__deepcopy__()
-
-
-
-
diff --git a/agml/io.py b/agml/io.py
index e5bd8b9d..43e80ddc 100644
--- a/agml/io.py
+++ b/agml/io.py
@@ -12,21 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import random
 import inspect
+import random
 
 import cv2
 
-from agml.utils.io import (
-    get_file_list as _get_file_list,
-    get_dir_list as _get_dir_list,
-    nested_file_list as _get_nested_file_list,
-    nested_dir_list as _get_nested_dir_list,
-    recursive_dirname as _recursive_dirname
-)
+from agml.utils.io import get_dir_list as _get_dir_list
+from agml.utils.io import get_file_list as _get_file_list
+from agml.utils.io import nested_dir_list as _get_nested_dir_list
+from agml.utils.io import nested_file_list as _get_nested_file_list
+from agml.utils.io import recursive_dirname as _recursive_dirname
 
 
-def get_file_list(path, ext = None, nested = False):
+def get_file_list(path, ext=None, nested=False):
     """Returns a list of files in a directory.
 
     This function returns a list of files in a directory, optionally
@@ -45,11 +43,11 @@ def get_file_list(path, ext = None, nested = False):
             extension.
     """
     if nested:
-        return _get_nested_file_list(path, ext = ext)
-    return _get_file_list(path, ext = ext)
+        return _get_nested_file_list(path, ext=ext)
+    return _get_file_list(path, ext=ext)
 
 
-def get_dir_list(path, nested = False):
+def get_dir_list(path, nested=False):
     """Returns a list of directories in a directory.
 
     This function returns a list of directories in a directory,
@@ -68,7 +66,7 @@ def get_dir_list(path, nested = False):
     return _get_dir_list(path)
 
 
-def recursive_dirname(path, depth = 1):
+def recursive_dirname(path, depth=1):
     """Returns the directory name of a path.
 
     This function returns the directory name of a path, optionally
@@ -84,7 +82,7 @@ def recursive_dirname(path, depth = 1):
     Returns:
         str: The directory name of the path.
     """
-    return _recursive_dirname(path, level = depth)
+    return _recursive_dirname(path, level=depth)
 
 
 def parent_path(depth):
@@ -98,7 +96,7 @@ def parent_path(depth):
     """
     frame = inspect.stack()[1]
     fname = inspect.getmodule(frame[0]).__file__
-    return _recursive_dirname(fname, level = depth)
+    return _recursive_dirname(fname, level=depth)
 
 
 def random_file(path, **kwargs):
@@ -125,4 +123,3 @@ def read_image(path, **kwargs):
         numpy.ndarray: The image.
     """
     return cv2.imread(path, **kwargs)
-
diff --git a/agml/models/__init__.py b/agml/models/__init__.py
index c6b585c5..6db5f722 100644
--- a/agml/models/__init__.py
+++ b/agml/models/__init__.py
@@ -22,25 +22,25 @@
 try:
     import torch
 except ImportError:
-    raise ImportError('Could not find a PyTorch installation. If you want to use '
-                      'the models in `agml.models`, you will need to install PyTorch '
-                      'first. Try `pip install torch` to do so.')
+    raise ImportError(
+        "Could not find a PyTorch installation. If you want to use "
+        "the models in `agml.models`, you will need to install PyTorch "
+        "first. Try `pip install torch` to do so."
+    )
 
 try:
     import pytorch_lightning
 except ImportError:
-    raise ImportError('Could not find a PyTorch Lightning installation. If you want to '
-                      'use the models in `agml.models`, you will need to install PyTorch '
-                      'Lightning first. Try `pip install pytorch-lightning` to do so.')
+    raise ImportError(
+        "Could not find a PyTorch Lightning installation. If you want to "
+        "use the models in `agml.models`, you will need to install PyTorch "
+        "Lightning first. Try `pip install pytorch-lightning` to do so."
+    )
 
 
+from . import legacy, losses, metrics, preprocessing
+from .benchmarks import get_benchmark
 from .classification import ClassificationModel
-from .segmentation import SegmentationModel
 from .detection import DetectionModel
 from .detector import Detector
-from . import metrics
-from . import losses
-from . import preprocessing
-from . import legacy
-from .benchmarks import get_benchmark
-
+from .segmentation import SegmentationModel
diff --git a/agml/models/base.py b/agml/models/base.py
index dd08568e..42562fdd 100644
--- a/agml/models/base.py
+++ b/agml/models/base.py
@@ -12,22 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import abc
+import os
 from typing import List, Union, overload
 
 import cv2
 import numpy as np
-
 import torch
 from pytorch_lightning import LightningModule
 
-from agml.framework import AgMLSerializable
 from agml.backend.config import model_save_path
 from agml.backend.tftorch import is_array_like
-from agml.utils.image import imread_context
-from agml.utils.downloads import download_model
+from agml.framework import AgMLSerializable
 from agml.models.benchmarks import BenchmarkMetadata
+from agml.utils.downloads import download_model
+from agml.utils.image import imread_context
 
 
 class AgMLModelBase(AgMLSerializable, LightningModule):
@@ -50,20 +49,16 @@ def original(self):
         return self.net.base
 
     @overload
-    def preprocess_input(self, images: str) -> "torch.Tensor":
-        ...
+    def preprocess_input(self, images: str) -> "torch.Tensor": ...
 
     @overload
-    def preprocess_input(self, images: List[str]) -> "torch.Tensor":
-        ...
+    def preprocess_input(self, images: List[str]) -> "torch.Tensor": ...
 
     @overload
-    def preprocess_input(self, images: Union[np.ndarray, torch.Tensor]) -> "torch.Tensor":
-        ...
+    def preprocess_input(self, images: Union[np.ndarray, torch.Tensor]) -> "torch.Tensor": ...
 
     @overload
-    def preprocess_input(self, images: List[Union[np.ndarray, torch.Tensor]]) -> "torch.Tensor":
-        ...
+    def preprocess_input(self, images: List[Union[np.ndarray, torch.Tensor]]) -> "torch.Tensor": ...
 
     @abc.abstractmethod
     def preprocess_input(self, *args, **kwargs):
@@ -71,20 +66,16 @@ def preprocess_input(self, *args, **kwargs):
         raise NotImplementedError
 
     @overload
-    def predict(self, images: str) -> "torch.Tensor":
-        ...
+    def predict(self, images: str) -> "torch.Tensor": ...
 
     @overload
-    def predict(self, images: List[str]) -> "torch.Tensor":
-        ...
+    def predict(self, images: List[str]) -> "torch.Tensor": ...
 
     @overload
-    def predict(self, images: Union[np.ndarray, torch.Tensor]) -> "torch.Tensor":
-        ...
+    def predict(self, images: Union[np.ndarray, torch.Tensor]) -> "torch.Tensor": ...
 
     @overload
-    def predict(self, images: List[Union[np.ndarray, torch.Tensor]]) -> "torch.Tensor":
-        ...
+    def predict(self, images: List[Union[np.ndarray, torch.Tensor]]) -> "torch.Tensor": ...
 
     @abc.abstractmethod
     def predict(self, *args, **kwargs):
@@ -105,7 +96,9 @@ def _expand_input_images(images):
         # First check for a path or a list of paths, for speed.
         if isinstance(images, str):
             with imread_context(images) as image:
-                return [cv2.cvtColor(image, cv2.COLOR_BGR2RGB), ]
+                return [
+                    cv2.cvtColor(image, cv2.COLOR_BGR2RGB),
+                ]
         elif isinstance(images, list) and isinstance(images[0], str):
             parsed_images = []
             for path in images:
@@ -119,7 +112,9 @@ def _expand_input_images(images):
             # Check if there is one single input image, or a batch of input
             # images. If there is a single input image, just return this.
             if images.ndim == 3:
-                return [images, ]
+                return [
+                    images,
+                ]
 
             # Check if we have a batch of images first. This check is
             # done by seeing if the input is 4-dimensional.
@@ -135,7 +130,8 @@ def _expand_input_images(images):
         raise TypeError(
             "Expected an input of a list of paths or images, a "
             "single path or image, or a batched image tensor for "
-            f"preprocessing inputs, instead got {type(images)}.")
+            f"preprocessing inputs, instead got {type(images)}."
+        )
 
     @staticmethod
     def _to_out(tensor: "torch.Tensor") -> "torch.Tensor":
@@ -149,9 +145,9 @@ def _get_shapes(images: list) -> list:
             if image.ndim == 2:
                 shapes.append(image.shape)
                 continue
-            if image.shape[0] <= 3: # channels first
+            if image.shape[0] <= 3:  # channels first
                 shapes.append(image.shape[1:])
-            else: # channels last
+            else:  # channels last
                 shapes.append(image.shape[:2])
         return shapes
 
@@ -168,12 +164,12 @@ def benchmark(self, value):
     def _get_benchmark(name):
         """Returns the `state_dict` for a pretrained model benchmark."""
         # Check if the benchmark exists; if not, download it.
-        benchmark_path = os.path.join(model_save_path(), name + '.pth')
+        benchmark_path = os.path.join(model_save_path(), name + ".pth")
         if not os.path.exists(benchmark_path):
             download_model(name, os.path.dirname(benchmark_path))
 
         # Load the benchmark.
-        return torch.load(benchmark_path, map_location = 'cpu')
+        return torch.load(benchmark_path, map_location="cpu")
 
     @abc.abstractmethod
     def load_benchmark(self, dataset: str):
@@ -191,28 +187,25 @@ def _prepare_for_training(self, **kwargs):
         raise NotImplementedError
 
     def on_train_epoch_end(self):
-        if self._ml_task != 'object_detection':
+        if self._ml_task != "object_detection":
             for _, metric in self._metrics:
                 metric.reset()
 
     def on_validation_epoch_end(self):
-        if self._ml_task != 'object_detection':
+        if self._ml_task != "object_detection":
             for _, metric in self._metrics:
                 metric.reset()
 
     def get_progress_bar_dict(self):
-        if not hasattr(super(), 'get_progress_bar_dict'):
+        if not hasattr(super(), "get_progress_bar_dict"):
             return
         tqdm_dict = super().get_progress_bar_dict()
-        tqdm_dict.pop('v_num', None)
+        tqdm_dict.pop("v_num", None)
         return tqdm_dict
 
     def get_metrics(self):
-        if not hasattr(super(), 'get_metrics'):
+        if not hasattr(super(), "get_metrics"):
             return
         tqdm_dict = super().get_metrics()
-        tqdm_dict.pop('v_num', None)
+        tqdm_dict.pop("v_num", None)
         return tqdm_dict
-
-
-
diff --git a/agml/models/benchmarks.py b/agml/models/benchmarks.py
index c00e25cf..c69d64ec 100644
--- a/agml/models/benchmarks.py
+++ b/agml/models/benchmarks.py
@@ -17,9 +17,8 @@
 from agml.framework import AgMLSerializable
 from agml.utils.data import load_model_benchmarks
 
-
 # Named tuples which are used by the metadata.
-Metric = collections.namedtuple('Metric', ['name', 'value'])
+Metric = collections.namedtuple("Metric", ["name", "value"])
 
 
 class BenchmarkMetadata(AgMLSerializable):
@@ -29,15 +28,21 @@ class BenchmarkMetadata(AgMLSerializable):
     this class is used to provide information regarding the benchmark,
     as well as key hyperparameters which can be used for reproducibility.
     """
-    serializable = frozenset(('dataset', 'meta'))
+
+    serializable = frozenset(("dataset", "meta"))
 
     def __init__(self, dataset):
         # Load the information for the given dataset.
         if dataset is None:
             self._dataset = None
-            self._meta = {'hyperparameters': {
-                'model_config': None, 'optimizer_config': None,
-                'metric': {None: None}, 'epochs_trained': None}}
+            self._meta = {
+                "hyperparameters": {
+                    "model_config": None,
+                    "optimizer_config": None,
+                    "metric": {None: None},
+                    "epochs_trained": None,
+                }
+            }
             return
         try:
             self._dataset = dataset
@@ -51,23 +56,23 @@ def __str__(self):
     @property
     def model_config(self):
         """Returns a dictionary with the configuration for the model."""
-        return self._meta['hyperparameters']['model_config']
+        return self._meta["hyperparameters"]["model_config"]
 
     @property
     def optimizer_config(self):
         """Returns a dictionary with the configuration for the optimizer."""
-        return self._meta['hyperparameters']['optimizer_config']
+        return self._meta["hyperparameters"]["optimizer_config"]
 
     @property
     def epochs_trained(self):
         """Returns the number of epochs the benchmark was trained for."""
-        return self._meta['hyperparameters']['epochs']
+        return self._meta["hyperparameters"]["epochs"]
 
     @property
     def metric(self):
         """Returns the value of the metric for the benchmark."""
-        name, value = list(self._meta['metric'].items())[0]
-        return Metric(name = name, value = value)
+        name, value = list(self._meta["metric"].items())[0]
+        return Metric(name=name, value=value)
 
 
 def get_benchmark(dataset):
@@ -78,8 +83,6 @@ def get_benchmark(dataset):
     dataset : str
         The name of the dataset or a DatasetMetadata object.
     """
-    if hasattr(dataset, 'name'):
+    if hasattr(dataset, "name"):
         dataset = dataset.name
     return BenchmarkMetadata(dataset)
-
-
diff --git a/agml/models/classification.py b/agml/models/classification.py
index a0a180fa..1c551b21 100644
--- a/agml/models/classification.py
+++ b/agml/models/classification.py
@@ -12,35 +12,37 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from tqdm import tqdm
-
 import torch
 import torch.nn as nn
+from tqdm import tqdm
 
 try:
     from torchvision.models import efficientnet_b4
 except ImportError:
-    raise ImportError("To use image classification models in `agml.models`, you "
-                      "need to install Torchvision first. You can do this by "
-                      "running `pip install torchvision`.")
+    raise ImportError(
+        "To use image classification models in `agml.models`, you "
+        "need to install Torchvision first. You can do this by "
+        "running `pip install torchvision`."
+    )
 
 from agml.models.base import AgMLModelBase
-from agml.models.tools import auto_move_data, imagenet_style_process
 from agml.models.metrics.accuracy import Accuracy
+from agml.models.tools import auto_move_data, imagenet_style_process
 from agml.utils.general import has_func
 
 
 class EfficientNetB4Transfer(nn.Module):
     """Wraps an EfficientDetB4 model with a classification head."""
+
     def __init__(self, num_classes):
         super(EfficientNetB4Transfer, self).__init__()
-        self.base = efficientnet_b4(pretrained = False)
+        self.base = efficientnet_b4(pretrained=False)
         self.l1 = nn.Linear(1000, 256)
         self.dropout = nn.Dropout(0.1)
         self.relu = nn.ReLU()
         self.l2 = nn.Linear(256, num_classes)
 
-    def forward(self, x, **kwargs): # noqa
+    def forward(self, x, **kwargs):  # noqa
         x = self.base(x)
         x = x.view(x.size(0), -1)
         x = self.dropout(self.relu(self.l1(x)))
@@ -69,16 +71,17 @@ class ClassificationModel(AgMLModelBase):
     parameter `net`, and you'll need to implement methods like `training_step`,
     `configure_optimizers`, etc. See PyTorch Lightning for more information.
     """
+
     serializable = frozenset(("model", "regression"))
     state_override = frozenset(("model",))
 
-    _ml_task = 'image_classification'
+    _ml_task = "image_classification"
 
-    def __init__(self, num_classes = None, regression = False, **kwargs):
+    def __init__(self, num_classes=None, regression=False, **kwargs):
         # Construct the network and load in pretrained weights.
         super(ClassificationModel, self).__init__()
         self._regression = regression
-        if not kwargs.get('model_initialized', False):
+        if not kwargs.get("model_initialized", False):
             self._num_classes = num_classes
             self.net = self._construct_sub_net(num_classes)
 
@@ -111,7 +114,7 @@ def _preprocess_image(image, **kwargs):
         return imagenet_style_process(image, **kwargs)
 
     @staticmethod
-    def preprocess_input(images = None, **kwargs) -> "torch.Tensor":
+    def preprocess_input(images=None, **kwargs) -> "torch.Tensor":
         """Preprocesses the input image to the specification of the model.
 
         This method takes in a set of inputs and preprocesses them into the
@@ -149,8 +152,9 @@ def preprocess_input(images = None, **kwargs) -> "torch.Tensor":
         """
         images = ClassificationModel._expand_input_images(images)
         return torch.stack(
-            [ClassificationModel._preprocess_image(
-                image, **kwargs) for image in images], dim = 0)
+            [ClassificationModel._preprocess_image(image, **kwargs) for image in images],
+            dim=0,
+        )
 
     @torch.no_grad()
     def predict(self, images, **kwargs):
@@ -180,9 +184,9 @@ def predict(self, images, **kwargs):
         """
         images = self.preprocess_input(images, **kwargs)
         out = self.forward(images)
-        if not self._regression: # standard classification
+        if not self._regression:  # standard classification
             out = torch.argmax(out, 1)
-        if not kwargs.get('return_tensor_output', False):
+        if not kwargs.get("return_tensor_output", False):
             return self._to_out(torch.squeeze(out))
         return out
 
@@ -202,34 +206,36 @@ def evaluate(self, loader, **kwargs):
         """
         # Construct the metric and run the calculations.
         acc = Accuracy()
-        bar = tqdm(loader, desc = "Calculating Accuracy")
+        bar = tqdm(loader, desc="Calculating Accuracy")
         for sample in bar:
             image, truth = sample
-            pred_label = self.predict(image, return_tensor_out = True, **kwargs)
+            pred_label = self.predict(image, return_tensor_out=True, **kwargs)
             acc.update(pred_label, truth)
-            bar.set_postfix({'accuracy': acc.compute().numpy().item()})
+            bar.set_postfix({"accuracy": acc.compute().numpy().item()})
 
         # Compute the final accuracy.
         return acc.compute().numpy().item()
 
-    def run_training(self,
-                     dataset=None,
-                     *,
-                     epochs=50,
-                     loss=None,
-                     metrics=None,
-                     optimizer=None,
-                     lr_scheduler=None,
-                     lr=None,
-                     batch_size=8,
-                     loggers=None,
-                     train_dataloader=None,
-                     val_dataloader=None,
-                     test_dataloader=None,
-                     use_cpu=False,
-                     save_dir=None,
-                     experiment_name=None,
-                     **kwargs):
+    def run_training(
+        self,
+        dataset=None,
+        *,
+        epochs=50,
+        loss=None,
+        metrics=None,
+        optimizer=None,
+        lr_scheduler=None,
+        lr=None,
+        batch_size=8,
+        loggers=None,
+        train_dataloader=None,
+        val_dataloader=None,
+        test_dataloader=None,
+        use_cpu=False,
+        save_dir=None,
+        experiment_name=None,
+        **kwargs,
+    ):
         """Trains an image classification model.
 
         This method can be used to train an image classification model on a given
@@ -319,33 +325,29 @@ def run_training(self,
 
         return train_classification(
             self,
-            dataset = dataset,
-            epochs = epochs,
-            loss = loss,
-            metrics = metrics,
-            optimizer = optimizer,
-            lr_scheduler = lr_scheduler,
-            lr = lr,
+            dataset=dataset,
+            epochs=epochs,
+            loss=loss,
+            metrics=metrics,
+            optimizer=optimizer,
+            lr_scheduler=lr_scheduler,
+            lr=lr,
             batch_size=batch_size,
-            loggers = loggers,
-            train_dataloader = train_dataloader,
-            val_dataloader = val_dataloader,
-            test_dataloader = test_dataloader,
-            use_cpu = use_cpu,
-            save_dir = save_dir,
-            experiment_name = experiment_name,
-            **kwargs
+            loggers=loggers,
+            train_dataloader=train_dataloader,
+            val_dataloader=val_dataloader,
+            test_dataloader=test_dataloader,
+            use_cpu=use_cpu,
+            save_dir=save_dir,
+            experiment_name=experiment_name,
+            **kwargs,
         )
 
-    def _prepare_for_training(self,
-                              loss = 'ce',
-                              metrics = (),
-                              optimizer = None,
-                              **kwargs):
+    def _prepare_for_training(self, loss="ce", metrics=(), optimizer=None, **kwargs):
         """Prepares this classification model for training."""
 
         # Initialize the loss
-        if loss == 'ce':
+        if loss == "ce":
             # either binary or multiclass, binary is likely never used
             if self._num_classes == 1:
                 self.loss = nn.BCEWithLogitsLoss()
@@ -353,8 +355,7 @@ def _prepare_for_training(self,
                 self.loss = nn.CrossEntropyLoss()
         else:
             if not isinstance(loss, nn.Module) or not callable(loss):
-                raise TypeError(
-                    f"Expected a callable loss function, but got '{type(loss)}'.")
+                raise TypeError(f"Expected a callable loss function, but got '{type(loss)}'.")
 
         # Initialize the metrics.
         metric_collection = []
@@ -368,24 +369,27 @@ def _prepare_for_training(self,
                         raise ImportError(
                             "Received the name of a metric. If you want to use named "
                             "metrics, then you need to have `torchmetrics` installed. "
-                            "You can do this by running `pip install torchmetrics`.")
+                            "You can do this by running `pip install torchmetrics`."
+                        )
 
                     # Check if `torchmetrics.classification` has the metric.
                     if has_func(class_metrics, metric):
                         # accuracy is a special case, we use our own accuracy
-                        if metric == 'accuracy':
+                        if metric == "accuracy":
                             from agml.models.metrics.accuracy import Accuracy
-                            metric_collection.append(['accuracy', Accuracy()])
+
+                            metric_collection.append(["accuracy", Accuracy()])
 
                         # convert to camel case
                         else:
-                            metric = ''.join([word.capitalize() for word in metric.split('_')])
+                            metric = "".join([word.capitalize() for word in metric.split("_")])
                             metric_collection.append([metric, getattr(class_metrics, metric)()])
                     else:
                         raise ValueError(
                             f"Expected a valid metric torchmetrics metric name, "
                             f"but got '{metric}'. Check `torchmetrics.classification` "
-                            f"for a list of valid image classification metrics.")
+                            f"for a list of valid image classification metrics."
+                        )
 
                 # Check if it is any other class.
                 elif isinstance(metric, nn.Module):
@@ -393,8 +397,7 @@ def _prepare_for_training(self,
 
                 # Otherwise, raise an error.
                 else:
-                    raise TypeError(
-                        f"Expected a metric name or a metric class, but got '{type(metric)}'.")
+                    raise TypeError(f"Expected a metric name or a metric class, but got '{type(metric)}'.")
         self._metrics = metric_collection
 
         # Initialize the optimizer/learning rate scheduler.
@@ -403,40 +406,39 @@ def _prepare_for_training(self,
             if not has_func(torch.optim, optimizer_class):
                 raise ValueError(
                     f"Expected a valid optimizer name, but got '{optimizer_class}'. "
-                    f"Check `torch.optim` for a list of valid optimizers.")
+                    f"Check `torch.optim` for a list of valid optimizers."
+                )
 
-            optimizer = getattr(torch.optim, optimizer_class)(
-                self.parameters(), lr = kwargs.get('lr', 1e-3))
+            optimizer = getattr(torch.optim, optimizer_class)(self.parameters(), lr=kwargs.get("lr", 1e-3))
         elif isinstance(optimizer, torch.optim.Optimizer):
             pass  # nothing to do
         else:
-            raise TypeError(
-                f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
+            raise TypeError(f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
 
-        scheduler = kwargs.get('lr_scheduler', None)
+        scheduler = kwargs.get("lr_scheduler", None)
         if scheduler is not None:
             # No string auto-initialization, the LR scheduler must be pre-configured.
             if isinstance(scheduler, str):
                 raise ValueError(
                     f"If you want to use a learning rate scheduler, you must initialize "
-                    f"it on your own and pass it to the `lr_scheduler` argument. ")
+                    f"it on your own and pass it to the `lr_scheduler` argument. "
+                )
             elif not isinstance(scheduler, torch.optim.lr_scheduler.LRScheduler):
-                raise TypeError(
-                    f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
+                raise TypeError(f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
 
         self._optimization_parameters = {
-            'optimizer': optimizer,
-            'lr_scheduler': scheduler
+            "optimizer": optimizer,
+            "lr_scheduler": scheduler,
         }
 
     def configure_optimizers(self):
-        opt = self._optimization_parameters['optimizer']
-        scheduler = self._optimization_parameters['lr_scheduler']
+        opt = self._optimization_parameters["optimizer"]
+        scheduler = self._optimization_parameters["lr_scheduler"]
         if scheduler is None:
             return opt
         return [opt], [scheduler]
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x)
 
@@ -444,26 +446,30 @@ def training_step(self, batch, *args, **kwargs): # noqa
         loss = self.loss(y_pred, y)
         for metric_name, metric in self._metrics:
             metric.update(y_pred, y)
-            self.log(metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(metric_name, self._to_out(metric.compute()).item(), prog_bar=True)
 
         return {
-            'loss': loss,
+            "loss": loss,
         }
 
-    def validation_step(self, batch, *args, **kwargs): # noqa
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self.net(x)
 
         # Compute metrics and loss.
         val_loss = self.loss(y_pred, y)
-        self.log('val_loss', val_loss.item(), prog_bar = True)
+        self.log("val_loss", val_loss.item(), prog_bar=True)
         for metric_name, metric in self._metrics:
             metric.to(self.device)
             metric.update(y_pred, y)
-            self.log('val_' + metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(
+                "val_" + metric_name,
+                self._to_out(metric.compute()).item(),
+                prog_bar=True,
+            )
 
         return {
-            'val_loss': val_loss,
+            "val_loss": val_loss,
         }
 
     def test_step(self, batch, *args, **kwargs):
@@ -472,18 +478,16 @@ def test_step(self, batch, *args, **kwargs):
 
         # Compute metrics and loss.
         test_loss = self.loss(y_pred, y)
-        self.log('test_loss', test_loss.item(), prog_bar = True)
+        self.log("test_loss", test_loss.item(), prog_bar=True)
         for metric_name, metric in self._metrics:
             metric.update(y_pred, y)
 
-            self.log('test_' + metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(
+                "test_" + metric_name,
+                self._to_out(metric.compute()).item(),
+                prog_bar=True,
+            )
 
         return {
-            'test_loss': test_loss,
+            "test_loss": test_loss,
         }
-
-
-
-
-
-
diff --git a/agml/models/detection.py b/agml/models/detection.py
index e88d9e5a..2edab0c0 100644
--- a/agml/models/detection.py
+++ b/agml/models/detection.py
@@ -14,11 +14,9 @@
 
 import warnings
 
-import numpy as np
 import albumentations as A
-
+import numpy as np
 import torch
-
 from tqdm import tqdm
 
 try:
@@ -30,12 +28,7 @@
     )
 
 try:
-    from effdet import (
-        create_model_from_config,
-        get_efficientdet_config,
-        DetBenchPredict,
-        DetBenchTrain
-    )
+    from effdet import DetBenchPredict, DetBenchTrain, create_model_from_config, get_efficientdet_config
 except ImportError:
     raise ImportError(
         "Could not find an installation of the `effdet` package. "
@@ -43,12 +36,12 @@
         "the version is important for proper functionality)."
     )
 
+from agml.backend.tftorch import is_array_like
+from agml.data.public import source
 from agml.models.base import AgMLModelBase
 from agml.models.benchmarks import BenchmarkMetadata
-from agml.models.tools import auto_move_data
 from agml.models.metrics.map import MeanAveragePrecision
-from agml.data.public import source
-from agml.backend.tftorch import is_array_like
+from agml.models.tools import auto_move_data
 from agml.utils.general import has_func
 from agml.utils.image import resolve_image_size
 from agml.utils.logging import log
@@ -91,23 +84,19 @@ class DetectionModel(AgMLModelBase):
     conf_threshold : float
         Filters bounding boxes by their level of confidence based on this threshold.
     """
-    serializable = frozenset((
-        "model", "num_classes", "conf_thresh", "image_size"))
+
+    serializable = frozenset(("model", "num_classes", "conf_thresh", "image_size"))
     state_override = frozenset(("model",))
 
-    _ml_task = 'object_detection'
+    _ml_task = "object_detection"
 
-    def __init__(self,
-                 num_classes = 1,
-                 image_size = 512,
-                 conf_threshold = 0.3,
-                 **kwargs):
+    def __init__(self, num_classes=1, image_size=512, conf_threshold=0.3, **kwargs):
         # Initialize the base modules.
         super(DetectionModel, self).__init__()
 
         # If being initialized by a subclass, then don't do any of
         # model construction logic (since that's already been done).
-        if not kwargs.get('model_initialized', False):
+        if not kwargs.get("model_initialized", False):
             # Construct the network and load in pretrained weights.
             self._image_size = resolve_image_size(image_size)
             self._confidence_threshold = conf_threshold
@@ -115,13 +104,12 @@ def __init__(self,
             self.model = self._construct_sub_net(
                 self._num_classes,
                 self._image_size,
-                pretrained = kwargs.get('pretrained', True))
+                pretrained=kwargs.get("pretrained", True),
+            )
 
         # Filter out unnecessary warnings.
-        warnings.filterwarnings(
-            'ignore', category = UserWarning, module = 'ensemble_boxes')
-        warnings.filterwarnings(
-            'ignore', category = UserWarning, module = 'effdet.bench')  # noqa
+        warnings.filterwarnings("ignore", category=UserWarning, module="ensemble_boxes")
+        warnings.filterwarnings("ignore", category=UserWarning, module="effdet.bench")  # noqa
 
     @auto_move_data
     def forward(self, *batch):
@@ -131,11 +119,10 @@ def forward(self, *batch):
         return self.model(batch[0])
 
     @staticmethod
-    def _construct_sub_net(num_classes, image_size, pretrained = False):
-        cfg = get_efficientdet_config('tf_efficientdet_d4')
+    def _construct_sub_net(num_classes, image_size, pretrained=False):
+        cfg = get_efficientdet_config("tf_efficientdet_d4")
         cfg.update({"image_size": image_size})
-        model = create_model_from_config(
-            cfg, pretrained = pretrained, num_classes = num_classes)
+        model = create_model_from_config(cfg, pretrained=pretrained, num_classes=num_classes)
         return DetBenchPredict(model)
 
     def switch_predict(self):
@@ -157,7 +144,7 @@ def original(self):  # override for detection models.
         return self.model.model
 
     @torch.jit.ignore()
-    def reset_class_net(self, num_classes = 1):
+    def reset_class_net(self, num_classes=1):
         """Reconfigures the output class net for a new number of classes.
 
         Parameters
@@ -166,7 +153,7 @@ def reset_class_net(self, num_classes = 1):
             The number of classes to reconfigure the output net to use.
         """
         if num_classes != self._num_classes:
-            self.model.model.reset_head(num_classes = num_classes)
+            self.model.model.reset_head(num_classes=num_classes)
 
     @staticmethod
     def _preprocess_image(image, image_size):
@@ -187,12 +174,12 @@ def _preprocess_image(image, image_size):
         dimension for two-channel inputs, for example.
         """
         # Convert the image to a NumPy array.
-        if is_array_like(image) and hasattr(image, 'numpy'):
+        if is_array_like(image) and hasattr(image, "numpy"):
             image = image.numpy()
 
         # Add a channel dimension for grayscale imagery.
         if image.ndim == 2:
-            image = np.expand_dims(image, axis = -1)
+            image = np.expand_dims(image, axis=-1)
 
         # If the image is already in channels-first format, convert
         # it back temporarily until preprocessing has concluded.
@@ -201,13 +188,13 @@ def _preprocess_image(image, image_size):
 
         # Resize the image to ImageNet standards.
         (w, h) = image_size
-        rz = A.Resize(height = h, width = w)
+        rz = A.Resize(height=h, width=w)
         if image.shape[0] != h or image.shape[1] != w:
-            image = rz(image = image)['image']
+            image = rz(image=image)["image"]
 
         # Normalize the image to ImageNet standards.
         if 1 <= image.max() <= 255:
-            image = image.astype(np.float32) / 255.
+            image = image.astype(np.float32) / 255.0
 
         # Convert the image into a PyTorch tensor.
         image = torch.from_numpy(image).permute(2, 0, 1)
@@ -216,7 +203,7 @@ def _preprocess_image(image, image_size):
         return image
 
     @torch.jit.ignore()
-    def preprocess_input(self, images, return_shapes = False):
+    def preprocess_input(self, images, return_shapes=False):
         """Preprocesses the input image to the specification of the model.
 
         This method takes in a set of inputs and preprocesses them into the
@@ -257,9 +244,7 @@ def preprocess_input(self, images, return_shapes = False):
         """
         images = self._expand_input_images(images)
         shapes = self._get_shapes(images)
-        images = torch.stack(
-            [self._preprocess_image(
-                image, self._image_size) for image in images], dim = 0)
+        images = torch.stack([self._preprocess_image(image, self._image_size) for image in images], dim=0)
         if return_shapes:
             return images, shapes
         return images
@@ -286,9 +271,7 @@ def _process_detections(self, detections):
 
         # Run weighted boxes fusion. For an exact description of how this
         # works, see the paper: https://arxiv.org/pdf/1910.13302.pdf.
-        (predicted_bboxes,
-         predicted_class_confidences,
-         predicted_class_labels) = self._wbf(predictions)
+        (predicted_bboxes, predicted_class_confidences, predicted_class_labels) = self._wbf(predictions)
         return predicted_bboxes, predicted_class_confidences, predicted_class_labels
 
     @staticmethod
@@ -299,7 +282,7 @@ def _rescale_bboxes(predicted_bboxes, image_sizes, yxyx=False):
             h, w = img_dims
             if len(bboxes) > 0:
                 # Move the device to the CPU.
-                if hasattr(bboxes, 'cpu'):
+                if hasattr(bboxes, "cpu"):
                     bboxes = bboxes.cpu()
 
                 # Re-scale the bounding box to the appropriate format.
@@ -331,9 +314,7 @@ def _wbf(predictions):
             labels = [prediction["classes"].tolist()]
 
             # Run the actual fusion and update the containers.
-            boxes, scores, labels = weighted_boxes_fusion(
-                boxes, scores, labels,
-                iou_thr = 0.44, skip_box_thr = 0.43)
+            boxes, scores, labels = weighted_boxes_fusion(boxes, scores, labels, iou_thr=0.44, skip_box_thr=0.43)
             boxes = boxes * (512 - 1)
             bboxes.append(boxes)
             confidences.append(scores)
@@ -343,14 +324,12 @@ def _wbf(predictions):
     @staticmethod
     def _remap_outputs(boxes, labels, confidences):
         """Remaps the outputs to the format described in `predict()`."""
-        squeeze = lambda *args: tuple(list(
-            np.squeeze(a).tolist() for a in args))
-        return [squeeze(b, l, c)
-                for b, l, c in zip(boxes, labels, confidences)]
+        squeeze = lambda *args: tuple(list(np.squeeze(a).tolist() for a in args))
+        return [squeeze(b, l, c) for b, l, c in zip(boxes, labels, confidences)]
 
     def _to_out(self, tensor: "torch.Tensor") -> "torch.Tensor":
         if isinstance(tensor, dict):
-            tensor = tensor['detections']
+            tensor = tensor["detections"]
         return super()._to_out(tensor)
 
     @torch.no_grad()
@@ -383,7 +362,7 @@ def predict(self, images):
         for the corresponding input image.
         """
         # Process the images and run inference.
-        images, shapes = self.preprocess_input(images, return_shapes = True)
+        images, shapes = self.preprocess_input(images, return_shapes=True)
         out = self._to_out(self.forward(images))
 
         # Post-process the output detections.
@@ -416,7 +395,7 @@ def show_prediction(self, image):
             bboxes, labels = [bboxes], [labels]
         return show_image_and_boxes(image, bboxes, labels)
 
-    def load_benchmark(self, dataset, strict = False):
+    def load_benchmark(self, dataset, strict=False):
         """Loads a benchmark for the given semantic segmentation dataset.
 
         This method is used to load pretrained weights for a specific AgML dataset.
@@ -439,11 +418,12 @@ def load_benchmark(self, dataset, strict = False):
         network weights (backbone, box network, etc.) will use the pretrained weights
         for the benchmark. This can be disabled by setting `strict = True`.
         """
-        if source(dataset).tasks.ml != 'object_detection':
+        if source(dataset).tasks.ml != "object_detection":
             raise ValueError(
                 f"You are trying to load a benchmark for a "
                 f"{source(dataset).tasks.ml} task ({dataset}) "
-                f"in an object detection model.")
+                f"in an object detection model."
+            )
 
         # Check loading strictness.
         cs = source(dataset).num_classes == self._num_classes
@@ -453,22 +433,25 @@ def load_benchmark(self, dataset, strict = False):
                     f"You cannot load a benchmark for a dataset '{dataset}' "
                     f"with {source(dataset).num_classes} classes, while your "
                     f"model has {self._num_classes} classes. If you want to, "
-                    f"then you need to set `strict = False`.")
+                    f"then you need to set `strict = False`."
+                )
 
         # Load the benchmark.
         state = self._get_benchmark(dataset)
         if not strict and not cs:
             self.reset_class_net(source(dataset).num_classes)
-            log(f"Loading a state dict for {dataset} with "
+            log(
+                f"Loading a state dict for {dataset} with "
                 f"{source(dataset).num_classes}, while your "
                 f"model has {self._num_classes} classes. The "
-                f"class network will use random weights.")
+                f"class network will use random weights."
+            )
         self.load_state_dict(state)
         if not strict and not cs:
             self.reset_class_net(self._num_classes)
         self._benchmark = BenchmarkMetadata(dataset)
 
-    def evaluate(self, loader, iou_threshold = 0.5, method = 'accumulate'):
+    def evaluate(self, loader, iou_threshold=0.5, method="accumulate"):
         """Runs a mean average precision evaluation on the given loader.
 
         This method will loop over the provided `AgMLDataLoader` and compute
@@ -493,57 +476,59 @@ def evaluate(self, loader, iou_threshold = 0.5, method = 'accumulate'):
         The final calculated mean average precision.
         """
         if not 0 < iou_threshold < 1:
-            raise ValueError(
-                f"The `iou_threshold` must be between 0 and 1, got {iou_threshold}.")
-        if method not in ['accumulate', 'average']:
-            raise ValueError(
-                f"Method must be either `accumulate` or `average`, got {method}.")
+            raise ValueError(f"The `iou_threshold` must be between 0 and 1, got {iou_threshold}.")
+        if method not in ["accumulate", "average"]:
+            raise ValueError(f"Method must be either `accumulate` or `average`, got {method}.")
 
         # Construct the mean average precision accumulator and run the calculations.
-        mean_ap = MeanAveragePrecision(
-            num_classes = self._num_classes, iou_threshold = iou_threshold)
-        bar = tqdm(loader, desc = "Calculating Mean Average Precision")
-        if method == 'average':
+        mean_ap = MeanAveragePrecision(num_classes=self._num_classes, iou_threshold=iou_threshold)
+        bar = tqdm(loader, desc="Calculating Mean Average Precision")
+        if method == "average":
             cumulative_maps = []
         for sample in bar:
             image, truth = sample
-            true_box, true_label = truth['bbox'], truth['category_id']
+            true_box, true_label = truth["bbox"], truth["category_id"]
             bboxes, labels, conf = self.predict(image)
-            mean_ap.update(*(
-                dict(boxes = bboxes, labels = labels, scores = conf),
-                dict(boxes = true_box, labels = true_label)))
+            mean_ap.update(
+                *(
+                    dict(boxes=bboxes, labels=labels, scores=conf),
+                    dict(boxes=true_box, labels=true_label),
+                )
+            )
 
             # If averaging, then calculate and reset the mAP, otherwise continue.
-            if method == 'average':
+            if method == "average":
                 res = mean_ap.compute()
-                cumulative_maps.append(res) # noqa
-                bar.set_postfix({'map': float(res)})
+                cumulative_maps.append(res)  # noqa
+                bar.set_postfix({"map": float(res)})
                 mean_ap.reset()
 
         # Compute the final mAP.
-        if method == 'average':
+        if method == "average":
             result = sum(cumulative_maps) / len(cumulative_maps)
         else:
             result = mean_ap.compute()
         return result
 
-    def run_training(self,
-                     dataset=None,
-                     *,
-                     epochs=50,
-                     metrics=None,
-                     optimizer=None,
-                     lr_scheduler=None,
-                     lr=None,
-                     batch_size=8,
-                     loggers=None,
-                     train_dataloader=None,
-                     val_dataloader=None,
-                     test_dataloader=None,
-                     use_cpu=False,
-                     save_dir=None,
-                     experiment_name=None,
-                     **kwargs):
+    def run_training(
+        self,
+        dataset=None,
+        *,
+        epochs=50,
+        metrics=None,
+        optimizer=None,
+        lr_scheduler=None,
+        lr=None,
+        batch_size=8,
+        loggers=None,
+        train_dataloader=None,
+        val_dataloader=None,
+        test_dataloader=None,
+        use_cpu=False,
+        save_dir=None,
+        experiment_name=None,
+        **kwargs,
+    ):
         """Trains an object detection model.
 
         This method can be used to train an object detection model on a given
@@ -632,27 +617,24 @@ def run_training(self,
 
         return train_detection(
             self,
-            dataset = dataset,
-            epochs = epochs,
-            metrics = metrics,
-            optimizer = optimizer,
-            lr_scheduler = lr_scheduler,
-            lr = lr,
+            dataset=dataset,
+            epochs=epochs,
+            metrics=metrics,
+            optimizer=optimizer,
+            lr_scheduler=lr_scheduler,
+            lr=lr,
             batch_size=batch_size,
-            loggers = loggers,
-            train_dataloader = train_dataloader,
-            val_dataloader = val_dataloader,
-            test_dataloader = test_dataloader,
-            use_cpu = use_cpu,
-            save_dir = save_dir,
-            experiment_name = experiment_name,
-            **kwargs
+            loggers=loggers,
+            train_dataloader=train_dataloader,
+            val_dataloader=val_dataloader,
+            test_dataloader=test_dataloader,
+            use_cpu=use_cpu,
+            save_dir=save_dir,
+            experiment_name=experiment_name,
+            **kwargs,
         )
 
-    def _prepare_for_training(self,
-                              metrics = (),
-                              optimizer = None,
-                              **kwargs):
+    def _prepare_for_training(self, metrics=(), optimizer=None, **kwargs):
         """Prepares the model for training."""
 
         # Initialize the metrics.
@@ -661,15 +643,16 @@ def _prepare_for_training(self,
             for metric in metrics:
                 # So far, only the mAP metric is supported.
                 if isinstance(metric, str):
-                    if metric.lower() not in ['ap', 'map']:
+                    if metric.lower() not in ["ap", "map"]:
                         raise ValueError(
                             "Unfortunately, the only currently supported metric "
                             "is mean average precision (use 'ap' or 'map' "
-                            "to enable mean average precision).")
+                            "to enable mean average precision)."
+                        )
 
                     self.map = MeanAveragePrecision(
-                        num_classes = self._num_classes,
-                        iou_threshold = kwargs.get('iou_threshold', 0.5)
+                        num_classes=self._num_classes,
+                        iou_threshold=kwargs.get("iou_threshold", 0.5),
                     )
 
         # Initialize the optimizer/learning rate scheduler.
@@ -678,36 +661,37 @@ def _prepare_for_training(self,
             if not has_func(torch.optim, optimizer_class):
                 raise ValueError(
                     f"Expected a valid optimizer name, but got '{optimizer_class}'. "
-                    f"Check `torch.optim` for a list of valid optimizers.")
+                    f"Check `torch.optim` for a list of valid optimizers."
+                )
 
             optimizer = getattr(torch.optim, optimizer_class)(
-                self.parameters(), lr = kwargs.get(
-                    'lr', 0.0002 if self._num_classes == 1 else 0.0008))
+                self.parameters(),
+                lr=kwargs.get("lr", 0.0002 if self._num_classes == 1 else 0.0008),
+            )
         elif isinstance(optimizer, torch.optim.Optimizer):
             pass  # nothing to do
         else:
-            raise TypeError(
-                f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
+            raise TypeError(f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
 
-        scheduler = kwargs.get('lr_scheduler', None)
+        scheduler = kwargs.get("lr_scheduler", None)
         if scheduler is not None:
             # No string auto-initialization, the LR scheduler must be pre-configured.
             if isinstance(scheduler, str):
                 raise ValueError(
                     f"If you want to use a learning rate scheduler, you must initialize "
-                    f"it on your own and pass it to the `lr_scheduler` argument. ")
+                    f"it on your own and pass it to the `lr_scheduler` argument. "
+                )
             elif not isinstance(scheduler, torch.optim.lr_scheduler.LRScheduler):
-                raise TypeError(
-                    f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
+                raise TypeError(f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
 
         self._optimization_parameters = {
-            'optimizer': optimizer,
-            'lr_scheduler': scheduler
+            "optimizer": optimizer,
+            "lr_scheduler": scheduler,
         }
 
     def configure_optimizers(self):
-        opt = self._optimization_parameters['optimizer']
-        scheduler = self._optimization_parameters['lr_scheduler']
+        opt = self._optimization_parameters["optimizer"]
+        scheduler = self._optimization_parameters["lr_scheduler"]
         if scheduler is None:
             return opt
         return [opt], [scheduler]
@@ -720,35 +704,50 @@ def training_step(self, batch, batch_idx, *args, **kwargs):
     def validation_step(self, batch, batch_idx, *args, **kwargs):
         images, annotations, targets = batch
         outputs = self(images, annotations)
-        detections = outputs['detections']
+        detections = outputs["detections"]
 
         # Calculate the mean average precision.
         if not self.trainer.sanity_checking and self.map is not None:
             boxes, confidences, labels = self._process_detections(self._to_out(detections))
-            if hasattr(boxes, 'cpu'):
+            if hasattr(boxes, "cpu"):
                 boxes = boxes.cpu()
-            if hasattr(annotations['bbox'], 'cpu'):
-                annotations['bbox'] = annotations['bbox'].cpu()
+            if hasattr(annotations["bbox"], "cpu"):
+                annotations["bbox"] = annotations["bbox"].cpu()
             boxes = self._rescale_bboxes(boxes, [[512, 512]] * len(images))
-            annotations['bbox'] = self._rescale_bboxes(
-                annotations['bbox'], [[512, 512, ]] * len(images), yxyx=True)
+            annotations["bbox"] = self._rescale_bboxes(
+                annotations["bbox"],
+                [
+                    [
+                        512,
+                        512,
+                    ]
+                ]
+                * len(images),
+                yxyx=True,
+            )
 
             for pred_box, pred_label, pred_conf, true_box, true_label in zip(
-                    boxes, labels, confidences, annotations['bbox'], annotations['cls']):
+                boxes, labels, confidences, annotations["bbox"], annotations["cls"]
+            ):
                 metric_update_values = (
-                    dict(boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
-                         labels=self._to_out(torch.tensor(pred_label, dtype=torch.int32)),
-                         scores=self._to_out(torch.tensor(pred_conf))),
-                    dict(boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
-                         labels=self._to_out(torch.tensor(true_label, dtype=torch.int32))))
+                    dict(
+                        boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
+                        labels=self._to_out(torch.tensor(pred_label, dtype=torch.int32)),
+                        scores=self._to_out(torch.tensor(pred_conf)),
+                    ),
+                    dict(
+                        boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
+                        labels=self._to_out(torch.tensor(true_label, dtype=torch.int32)),
+                    ),
+                )
                 self.map.update(*metric_update_values)
 
                 # Log the MAP values.
                 map_ = self.map.compute().detach().cpu().numpy().item()
                 self.log("val_map", map_, prog_bar=True, logger=True, sync_dist=True)
 
-        self.log("val_loss", outputs['loss'], prog_bar=True, logger=True, sync_dist=True)
-        return outputs['loss']
+        self.log("val_loss", outputs["loss"], prog_bar=True, logger=True, sync_dist=True)
+        return outputs["loss"]
 
     def on_validation_epoch_end(self):
         if self.map is not None:
@@ -760,36 +759,43 @@ def test_step(self, batch, batch_idx, *args, **kwargs):
 
         # Calculate the mean average precision.
         if not self.trainer.sanity_checking and self.map is not None:
-            boxes, confidences, labels = self._process_detections(self._to_out(outputs['detections']))
-            if hasattr(boxes, 'cpu'):
+            boxes, confidences, labels = self._process_detections(self._to_out(outputs["detections"]))
+            if hasattr(boxes, "cpu"):
                 boxes = boxes.cpu()
-            if hasattr(annotations['bbox'], 'cpu'):
-                annotations['bbox'] = annotations['bbox'].cpu()
+            if hasattr(annotations["bbox"], "cpu"):
+                annotations["bbox"] = annotations["bbox"].cpu()
             boxes = self._rescale_bboxes(boxes, [[512, 512]] * len(images))
-            annotations['bbox'] = self._rescale_bboxes(
-                annotations['bbox'], [[512, 512, ]] * len(images), yxyx=True)
+            annotations["bbox"] = self._rescale_bboxes(
+                annotations["bbox"],
+                [
+                    [
+                        512,
+                        512,
+                    ]
+                ]
+                * len(images),
+                yxyx=True,
+            )
 
             for pred_box, pred_label, pred_conf, true_box, true_label in zip(
-                    boxes, labels, confidences, annotations['bbox'], annotations['cls']):
+                boxes, labels, confidences, annotations["bbox"], annotations["cls"]
+            ):
                 metric_update_values = (
-                    dict(boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
-                         labels=self._to_out(torch.tensor(pred_label, dtype=torch.int32)),
-                         scores=self._to_out(torch.tensor(pred_conf))),
-                    dict(boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
-                         labels=self._to_out(torch.tensor(true_label, dtype=torch.int32))))
+                    dict(
+                        boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
+                        labels=self._to_out(torch.tensor(pred_label, dtype=torch.int32)),
+                        scores=self._to_out(torch.tensor(pred_conf)),
+                    ),
+                    dict(
+                        boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
+                        labels=self._to_out(torch.tensor(true_label, dtype=torch.int32)),
+                    ),
+                )
                 self.map.update(*metric_update_values)
 
                 # Log the MAP values.
                 map_ = self.map.compute().detach().cpu().numpy().item()
                 self.log("test_map", map_, prog_bar=True, logger=True, sync_dist=True)
 
-        self.log("test_loss", outputs['loss'], prog_bar=True, logger=True, sync_dist=True)
-        return outputs['loss']
-
-
-
-
-
-
-
-
+        self.log("test_loss", outputs["loss"], prog_bar=True, logger=True, sync_dist=True)
+        return outputs["loss"]
diff --git a/agml/models/detector.py b/agml/models/detector.py
index c95a0af5..9ac4db1a 100644
--- a/agml/models/detector.py
+++ b/agml/models/detector.py
@@ -12,31 +12,29 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
+import datetime
 import gc
+import importlib
 import json
+import os
 import shutil
 import warnings
-import datetime
-import importlib
 
 import numpy as np
 import torch
 
-from agml.framework import AgMLSerializable
 from agml.backend.config import model_save_path
-from agml.utils.logging import log
+from agml.data.public import public_data_sources, source
+from agml.data.tools import convert_bbox_format
+from agml.framework import AgMLSerializable
+from agml.models.extensions.ultralytics import install_and_configure_ultralytics
 from agml.utils.data import load_detector_benchmarks
 from agml.utils.downloads import download_detector
+from agml.utils.logging import log
 from agml.viz.boxes import show_image_and_boxes
 
-from agml.data.public import source
-from agml.data.public import public_data_sources
-from agml.data.tools import convert_bbox_format
-from agml.models.extensions.ultralytics import install_and_configure_ultralytics
-
 try:
-    warnings.filterwarnings("ignore", message='.*Python>=3.10 is required')
+    warnings.filterwarnings("ignore", message=".*Python>=3.10 is required")
     import ultralytics
     from ultralytics import YOLO
 except ImportError:
@@ -44,8 +42,8 @@
     ultralytics = None
 
 
-VALID_YOLO11_MODELS = ['YOLO11n', 'YOLO11s', 'YOLO11m', 'YOLO11l', 'YOLO11x']
-YOLO11_MODELS_TO_PATH = {k.upper(): f'{k.lower()}.pt' for k in VALID_YOLO11_MODELS}
+VALID_YOLO11_MODELS = ["YOLO11n", "YOLO11s", "YOLO11m", "YOLO11l", "YOLO11x"]
+YOLO11_MODELS_TO_PATH = {k.upper(): f"{k.lower()}.pt" for k in VALID_YOLO11_MODELS}
 
 
 class Detector(AgMLSerializable):
@@ -69,10 +67,11 @@ class Detector(AgMLSerializable):
     and `Detector.load_benchmark` for loading models. The `Detector` class is
     designed to be a simple and easy-to-use interface for YOLO object detection.
     """
-    serializable = frozenset(('net', '_verbose'))
+
+    serializable = frozenset(("net", "_verbose"))
 
     # the default path to save the models in the AgML internal model repository.
-    DEFAULT_MODEL_PATH = os.path.join(model_save_path(), 'detectors')
+    DEFAULT_MODEL_PATH = os.path.join(model_save_path(), "detectors")
 
     def __new__(cls, net, *args, **kwargs):
         # only setup Ultralytics when the class is initialized
@@ -86,14 +85,16 @@ def __new__(cls, net, *args, **kwargs):
 
     def __init__(self, net, *args, **kwargs):
         if not kwargs.get("_internally_instantiated", False):
-            raise TypeError("An `agml.models.Detector` should only be instantiated "
-                            "from the `Detector.load(<name>)` method or the "
-                            "`Detector.load_benchmark(<name>)` method.")
+            raise TypeError(
+                "An `agml.models.Detector` should only be instantiated "
+                "from the `Detector.load(<name>)` method or the "
+                "`Detector.load_benchmark(<name>)` method."
+            )
 
         self.net = net
 
-        self._verbose = kwargs.get('verbose', False)
-        self._benchmark_data = kwargs.get('benchmark_data', None)
+        self._verbose = kwargs.get("verbose", False)
+        self._benchmark_data = kwargs.get("benchmark_data", None)
         self._info = None
 
     def __call__(self, image, return_full=False, **kwargs):
@@ -119,7 +120,7 @@ def _single_input_inference(self, image, return_full, **kwargs):
         result_dict = result_dict.cpu().numpy()
         boxes = result_dict.boxes
         bboxes = boxes.xyxy.astype(np.float32)
-        bboxes = convert_bbox_format(bboxes, 'xyxy')
+        bboxes = convert_bbox_format(bboxes, "xyxy")
         classes = boxes.cls.astype(np.int32)
         confidences = boxes.conf.astype(np.float32)
         return bboxes, classes, confidences
@@ -176,7 +177,8 @@ def verbose(self):
 
     @verbose.setter
     def verbose(self, value):
-        if not isinstance(value, bool): raise ValueError("Verbose must be True/False.")
+        if not isinstance(value, bool):
+            raise ValueError("Verbose must be True/False.")
         self._verbose = value
 
     @property
@@ -222,8 +224,7 @@ def train(loader, model, run_name=None, epochs=100, overwrite=False, **kwargs):
         model_save_dir = os.path.join(Detector.DEFAULT_MODEL_PATH, run_name)
         if os.path.exists(model_save_dir):
             if os.listdir(model_save_dir) and not overwrite:
-                raise ValueError(f"Model with name {run_name} already exists. "
-                                 f"Set `overwrite=True` to overwrite.")
+                raise ValueError(f"Model with name {run_name} already exists. " f"Set `overwrite=True` to overwrite.")
         os.makedirs(model_save_dir, exist_ok=True)
 
         # export the YOLO dataset in the Ultralytics package directory
@@ -236,32 +237,32 @@ def train(loader, model, run_name=None, epochs=100, overwrite=False, **kwargs):
             raise ValueError(f"Invalid model choice: {model}. Choose from: {VALID_YOLO11_MODELS}")
 
         with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", message='.*torch.amp.autocast')
+            warnings.filterwarnings("ignore", message=".*torch.amp.autocast")
             train_result = net.train(
                 epochs=epochs,
-                data=export_path_dict['metadata_path'],
-                save_dir=f'runs/train/{run_name}',
-                **kwargs
+                data=export_path_dict["metadata_path"],
+                save_dir=f"runs/train/{run_name}",
+                **kwargs,
             )
 
-            model_save_path = train_result.save_dir / 'weights' / 'best.pt'
-            model_results_csv = train_result.save_dir / 'results.csv'
-            model_args_path = train_result.save_dir / 'args.yaml'
+            model_save_path = train_result.save_dir / "weights" / "best.pt"
+            model_results_csv = train_result.save_dir / "results.csv"
+            model_args_path = train_result.save_dir / "args.yaml"
 
             # compose a complete result dictionary
             results = train_result.results_dict
-            results['class_map'] = {
-                'classes': train_result.names,
-                'maps': train_result.maps.tolist()
+            results["class_map"] = {
+                "classes": train_result.names,
+                "maps": train_result.maps.tolist(),
             }
-            with open(os.path.join(model_save_dir, 'results.json'), 'w') as f:
+            with open(os.path.join(model_save_dir, "results.json"), "w") as f:
                 json.dump(results, f, indent=4)
 
         # move the trained model to the `~/.agml/models` directory where it
         # will sit under the name `run_name` for easy loading in the future
-        shutil.move(model_save_path, os.path.join(model_save_dir, 'best.pt'))
-        shutil.move(model_results_csv, os.path.join(model_save_dir, 'results.csv'))
-        shutil.move(model_args_path, os.path.join(model_save_dir, 'args.yaml'))
+        shutil.move(model_save_path, os.path.join(model_save_dir, "best.pt"))
+        shutil.move(model_results_csv, os.path.join(model_save_dir, "results.csv"))
+        shutil.move(model_args_path, os.path.join(model_save_dir, "args.yaml"))
         log(f"""Model training complete. Model saved to: {model_save_dir}
 
         For full Ultralytics training logs and outputs, see: {train_result.save_dir}
@@ -311,12 +312,14 @@ def load(cls, name: str = None, weights: str = None, **kwargs):
         if name is not None and weights is not None:
             raise ValueError("You can only provide either a `name` or `weights` argument, not both.")
         if name is not None:
-            model_path = os.path.join(Detector.DEFAULT_MODEL_PATH, name, 'best.pt')
+            model_path = os.path.join(Detector.DEFAULT_MODEL_PATH, name, "best.pt")
             if not os.path.exists(model_path):
-                raise FileNotFoundError(f"Model with name {name} not found in the "
-                                        f"internal AgML model repository at {model_path}. If "
-                                        f"you want to load a custom path to weights, pass the "
-                                        f"`weights` argument instead of `name`.")
+                raise FileNotFoundError(
+                    f"Model with name {name} not found in the "
+                    f"internal AgML model repository at {model_path}. If "
+                    f"you want to load a custom path to weights, pass the "
+                    f"`weights` argument instead of `name`."
+                )
         if weights is not None:
             model_path = weights
             if not os.path.exists(model_path):
@@ -353,11 +356,11 @@ def load_benchmark(cls, dataset_name, yolo_model, **kwargs):
         -------
         The loaded YOLO model.
         """
-        if dataset_name not in public_data_sources(ml_task='object_detection'):
+        if dataset_name not in public_data_sources(ml_task="object_detection"):
             raise ValueError(f"Dataset {dataset_name} is not a valid object detection dataset.")
         if yolo_model.upper() not in YOLO11_MODELS_TO_PATH.keys():
             if len(yolo_model) == 1:
-                yolo_model = 'yolo11' + yolo_model
+                yolo_model = "yolo11" + yolo_model
                 if yolo_model not in YOLO11_MODELS_TO_PATH.keys():
                     raise ValueError(f"YOLO model {yolo_model} is not a valid YOLO11 model.")
             raise ValueError(f"YOLO model {yolo_model} is not a valid YOLO11 model.")
@@ -368,18 +371,12 @@ def load_benchmark(cls, dataset_name, yolo_model, **kwargs):
             raise ValueError(f"Could not find a valid benchmark for model ({model_name}).")
 
         # Download the model if it does not exist
-        if not os.path.exists(os.path.join(Detector.DEFAULT_MODEL_PATH, model_name.replace('+', '-'))):
+        if not os.path.exists(os.path.join(Detector.DEFAULT_MODEL_PATH, model_name.replace("+", "-"))):
             download_detector(model_name, Detector.DEFAULT_MODEL_PATH)
 
         # Load the model
         benchmark_data = load_detector_benchmarks()[model_name]
-        model_path = os.path.join(Detector.DEFAULT_MODEL_PATH, model_name.replace('+', '-'), 'best.pt')
+        model_path = os.path.join(Detector.DEFAULT_MODEL_PATH, model_name.replace("+", "-"), "best.pt")
         net = cls.load(weights=model_path, benchmark_data=benchmark_data, **kwargs)
         net._info = source(dataset_name)
         return net
-
-
-
-
-
-
diff --git a/agml/models/extensions/ultralytics.py b/agml/models/extensions/ultralytics.py
index e3097f59..8c718ac6 100644
--- a/agml/models/extensions/ultralytics.py
+++ b/agml/models/extensions/ultralytics.py
@@ -12,20 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import importlib
+import os
 import subprocess
 
 from agml.utils.logging import log
 
-
 # Only install the packages that are not already installed, and ignore
 # the ones that are not needed for basic YOLO training (minimize environment).
 manually_filtered_yolo_requirements = [
-    'thop>=0.1.1',
-    'ultralytics>=8.2.34',
-    'psutil',
-    'gitpython>=3.1.30'
+    "thop>=0.1.1",
+    "ultralytics>=8.2.34",
+    "psutil",
+    "gitpython>=3.1.30",
 ]
 
 
@@ -37,23 +36,20 @@ def install_and_configure_ultralytics():
         try:
             importlib.import_module(package)
         except ImportError:
-            subprocess.run(['pip', 'install', package])
+            subprocess.run(["pip", "install", package])
 
     # install the ultralytics package
-    subprocess.run(['pip', 'install', 'ultralytics'])
+    subprocess.run(["pip", "install", "ultralytics"])
 
     # ensure that packages are the right version (too high causes errors)
-    pillow_version = importlib.import_module('PIL').__version__
-    pillow_version_tuple = tuple(map(int, pillow_version.split('.')))
+    pillow_version = importlib.import_module("PIL").__version__
+    pillow_version_tuple = tuple(map(int, pillow_version.split(".")))
     if pillow_version_tuple > (9, 5, 0):
-        log(f'Detected Pillow version ({pillow_version}) is too high, downgrading to 9.5.0')
-        subprocess.run(['pip', 'install', '"Pillow<=9.5.0"'])
+        log(f"Detected Pillow version ({pillow_version}) is too high, downgrading to 9.5.0")
+        subprocess.run(["pip", "install", '"Pillow<=9.5.0"'])
 
-    hf_hub_version = importlib.import_module('huggingface_hub').__version__
-    hf_hub_version_tuple = tuple(map(int, hf_hub_version.split('.')))
+    hf_hub_version = importlib.import_module("huggingface_hub").__version__
+    hf_hub_version_tuple = tuple(map(int, hf_hub_version.split(".")))
     if hf_hub_version_tuple > (0, 24, 7):
-        log(f'Detected huggingface-hub version ({hf_hub_version}) is too high, downgrading to 0.24.7')
-        subprocess.run(['pip', 'install', '"huggingface-hub==0.24.7"'])
-
-
-
+        log(f"Detected huggingface-hub version ({hf_hub_version}) is too high, downgrading to 0.24.7")
+        subprocess.run(["pip", "install", '"huggingface-hub==0.24.7"'])
diff --git a/agml/models/legacy/__init__.py b/agml/models/legacy/__init__.py
index 6689db78..0e22fc73 100644
--- a/agml/models/legacy/__init__.py
+++ b/agml/models/legacy/__init__.py
@@ -13,5 +13,5 @@
 # limitations under the License.
 
 from .classification_efficientnet import ClassificationModel
-from .segmentation_deeplab import SegmentationModel
 from .detection_efficientdet import DetectionModel
+from .segmentation_deeplab import SegmentationModel
diff --git a/agml/models/legacy/classification_efficientnet.py b/agml/models/legacy/classification_efficientnet.py
index 93a8bae5..1c551b21 100644
--- a/agml/models/legacy/classification_efficientnet.py
+++ b/agml/models/legacy/classification_efficientnet.py
@@ -12,35 +12,37 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from tqdm import tqdm
-
 import torch
 import torch.nn as nn
+from tqdm import tqdm
 
 try:
     from torchvision.models import efficientnet_b4
 except ImportError:
-    raise ImportError("To use image classification models in `agml.models`, you "
-                      "need to install Torchvision first. You can do this by "
-                      "running `pip install torchvision`.")
+    raise ImportError(
+        "To use image classification models in `agml.models`, you "
+        "need to install Torchvision first. You can do this by "
+        "running `pip install torchvision`."
+    )
 
 from agml.models.base import AgMLModelBase
-from agml.models.tools import auto_move_data, imagenet_style_process
 from agml.models.metrics.accuracy import Accuracy
+from agml.models.tools import auto_move_data, imagenet_style_process
 from agml.utils.general import has_func
 
 
 class EfficientNetB4Transfer(nn.Module):
     """Wraps an EfficientDetB4 model with a classification head."""
+
     def __init__(self, num_classes):
         super(EfficientNetB4Transfer, self).__init__()
-        self.base = efficientnet_b4(pretrained = False)
+        self.base = efficientnet_b4(pretrained=False)
         self.l1 = nn.Linear(1000, 256)
         self.dropout = nn.Dropout(0.1)
         self.relu = nn.ReLU()
         self.l2 = nn.Linear(256, num_classes)
 
-    def forward(self, x, **kwargs): # noqa
+    def forward(self, x, **kwargs):  # noqa
         x = self.base(x)
         x = x.view(x.size(0), -1)
         x = self.dropout(self.relu(self.l1(x)))
@@ -69,16 +71,17 @@ class ClassificationModel(AgMLModelBase):
     parameter `net`, and you'll need to implement methods like `training_step`,
     `configure_optimizers`, etc. See PyTorch Lightning for more information.
     """
+
     serializable = frozenset(("model", "regression"))
     state_override = frozenset(("model",))
 
-    _ml_task = 'image_classification'
+    _ml_task = "image_classification"
 
-    def __init__(self, num_classes = None, regression = False, **kwargs):
+    def __init__(self, num_classes=None, regression=False, **kwargs):
         # Construct the network and load in pretrained weights.
         super(ClassificationModel, self).__init__()
         self._regression = regression
-        if not kwargs.get('model_initialized', False):
+        if not kwargs.get("model_initialized", False):
             self._num_classes = num_classes
             self.net = self._construct_sub_net(num_classes)
 
@@ -111,7 +114,7 @@ def _preprocess_image(image, **kwargs):
         return imagenet_style_process(image, **kwargs)
 
     @staticmethod
-    def preprocess_input(images = None, **kwargs) -> "torch.Tensor":
+    def preprocess_input(images=None, **kwargs) -> "torch.Tensor":
         """Preprocesses the input image to the specification of the model.
 
         This method takes in a set of inputs and preprocesses them into the
@@ -149,8 +152,9 @@ def preprocess_input(images = None, **kwargs) -> "torch.Tensor":
         """
         images = ClassificationModel._expand_input_images(images)
         return torch.stack(
-            [ClassificationModel._preprocess_image(
-                image, **kwargs) for image in images], dim = 0)
+            [ClassificationModel._preprocess_image(image, **kwargs) for image in images],
+            dim=0,
+        )
 
     @torch.no_grad()
     def predict(self, images, **kwargs):
@@ -180,9 +184,9 @@ def predict(self, images, **kwargs):
         """
         images = self.preprocess_input(images, **kwargs)
         out = self.forward(images)
-        if not self._regression: # standard classification
+        if not self._regression:  # standard classification
             out = torch.argmax(out, 1)
-        if not kwargs.get('return_tensor_output', False):
+        if not kwargs.get("return_tensor_output", False):
             return self._to_out(torch.squeeze(out))
         return out
 
@@ -202,34 +206,36 @@ def evaluate(self, loader, **kwargs):
         """
         # Construct the metric and run the calculations.
         acc = Accuracy()
-        bar = tqdm(loader, desc = "Calculating Accuracy")
+        bar = tqdm(loader, desc="Calculating Accuracy")
         for sample in bar:
             image, truth = sample
-            pred_label = self.predict(image, return_tensor_out = True, **kwargs)
+            pred_label = self.predict(image, return_tensor_out=True, **kwargs)
             acc.update(pred_label, truth)
-            bar.set_postfix({'accuracy': acc.compute().numpy().item()})
+            bar.set_postfix({"accuracy": acc.compute().numpy().item()})
 
         # Compute the final accuracy.
         return acc.compute().numpy().item()
 
-    def run_training(self,
-                     dataset=None,
-                     *,
-                     epochs=50,
-                     loss=None,
-                     metrics=None,
-                     optimizer=None,
-                     lr_scheduler=None,
-                     lr=None,
-                     batch_size=8,
-                     loggers=None,
-                     train_dataloader=None,
-                     val_dataloader=None,
-                     test_dataloader=None,
-                     use_cpu=False,
-                     save_dir=None,
-                     experiment_name=None,
-                     **kwargs):
+    def run_training(
+        self,
+        dataset=None,
+        *,
+        epochs=50,
+        loss=None,
+        metrics=None,
+        optimizer=None,
+        lr_scheduler=None,
+        lr=None,
+        batch_size=8,
+        loggers=None,
+        train_dataloader=None,
+        val_dataloader=None,
+        test_dataloader=None,
+        use_cpu=False,
+        save_dir=None,
+        experiment_name=None,
+        **kwargs,
+    ):
         """Trains an image classification model.
 
         This method can be used to train an image classification model on a given
@@ -319,33 +325,29 @@ def run_training(self,
 
         return train_classification(
             self,
-            dataset = dataset,
-            epochs = epochs,
-            loss = loss,
-            metrics = metrics,
-            optimizer = optimizer,
-            lr_scheduler = lr_scheduler,
-            lr = lr,
+            dataset=dataset,
+            epochs=epochs,
+            loss=loss,
+            metrics=metrics,
+            optimizer=optimizer,
+            lr_scheduler=lr_scheduler,
+            lr=lr,
             batch_size=batch_size,
-            loggers = loggers,
-            train_dataloader = train_dataloader,
-            val_dataloader = val_dataloader,
-            test_dataloader = test_dataloader,
-            use_cpu = use_cpu,
-            save_dir = save_dir,
-            experiment_name = experiment_name,
-            **kwargs
+            loggers=loggers,
+            train_dataloader=train_dataloader,
+            val_dataloader=val_dataloader,
+            test_dataloader=test_dataloader,
+            use_cpu=use_cpu,
+            save_dir=save_dir,
+            experiment_name=experiment_name,
+            **kwargs,
         )
 
-    def _prepare_for_training(self,
-                              loss = 'ce',
-                              metrics = (),
-                              optimizer = None,
-                              **kwargs):
+    def _prepare_for_training(self, loss="ce", metrics=(), optimizer=None, **kwargs):
         """Prepares this classification model for training."""
 
         # Initialize the loss
-        if loss == 'ce':
+        if loss == "ce":
             # either binary or multiclass, binary is likely never used
             if self._num_classes == 1:
                 self.loss = nn.BCEWithLogitsLoss()
@@ -353,8 +355,7 @@ def _prepare_for_training(self,
                 self.loss = nn.CrossEntropyLoss()
         else:
             if not isinstance(loss, nn.Module) or not callable(loss):
-                raise TypeError(
-                    f"Expected a callable loss function, but got '{type(loss)}'.")
+                raise TypeError(f"Expected a callable loss function, but got '{type(loss)}'.")
 
         # Initialize the metrics.
         metric_collection = []
@@ -368,24 +369,27 @@ def _prepare_for_training(self,
                         raise ImportError(
                             "Received the name of a metric. If you want to use named "
                             "metrics, then you need to have `torchmetrics` installed. "
-                            "You can do this by running `pip install torchmetrics`.")
+                            "You can do this by running `pip install torchmetrics`."
+                        )
 
                     # Check if `torchmetrics.classification` has the metric.
                     if has_func(class_metrics, metric):
                         # accuracy is a special case, we use our own accuracy
-                        if metric == 'accuracy':
+                        if metric == "accuracy":
                             from agml.models.metrics.accuracy import Accuracy
-                            metric_collection.append(['accuracy', Accuracy()])
+
+                            metric_collection.append(["accuracy", Accuracy()])
 
                         # convert to camel case
                         else:
-                            metric = ''.join([word.capitalize() for word in metric.split('_')])
+                            metric = "".join([word.capitalize() for word in metric.split("_")])
                             metric_collection.append([metric, getattr(class_metrics, metric)()])
                     else:
                         raise ValueError(
                             f"Expected a valid metric torchmetrics metric name, "
                             f"but got '{metric}'. Check `torchmetrics.classification` "
-                            f"for a list of valid image classification metrics.")
+                            f"for a list of valid image classification metrics."
+                        )
 
                 # Check if it is any other class.
                 elif isinstance(metric, nn.Module):
@@ -393,8 +397,7 @@ def _prepare_for_training(self,
 
                 # Otherwise, raise an error.
                 else:
-                    raise TypeError(
-                        f"Expected a metric name or a metric class, but got '{type(metric)}'.")
+                    raise TypeError(f"Expected a metric name or a metric class, but got '{type(metric)}'.")
         self._metrics = metric_collection
 
         # Initialize the optimizer/learning rate scheduler.
@@ -403,40 +406,39 @@ def _prepare_for_training(self,
             if not has_func(torch.optim, optimizer_class):
                 raise ValueError(
                     f"Expected a valid optimizer name, but got '{optimizer_class}'. "
-                    f"Check `torch.optim` for a list of valid optimizers.")
+                    f"Check `torch.optim` for a list of valid optimizers."
+                )
 
-            optimizer = getattr(torch.optim, optimizer_class)(
-                self.parameters(), lr = kwargs.get('lr', 1e-3))
+            optimizer = getattr(torch.optim, optimizer_class)(self.parameters(), lr=kwargs.get("lr", 1e-3))
         elif isinstance(optimizer, torch.optim.Optimizer):
             pass  # nothing to do
         else:
-            raise TypeError(
-                f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
+            raise TypeError(f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
 
-        scheduler = kwargs.get('lr_scheduler', None)
+        scheduler = kwargs.get("lr_scheduler", None)
         if scheduler is not None:
             # No string auto-initialization, the LR scheduler must be pre-configured.
             if isinstance(scheduler, str):
                 raise ValueError(
                     f"If you want to use a learning rate scheduler, you must initialize "
-                    f"it on your own and pass it to the `lr_scheduler` argument. ")
+                    f"it on your own and pass it to the `lr_scheduler` argument. "
+                )
             elif not isinstance(scheduler, torch.optim.lr_scheduler.LRScheduler):
-                raise TypeError(
-                    f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
+                raise TypeError(f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
 
         self._optimization_parameters = {
-            'optimizer': optimizer,
-            'lr_scheduler': scheduler
+            "optimizer": optimizer,
+            "lr_scheduler": scheduler,
         }
 
     def configure_optimizers(self):
-        opt = self._optimization_parameters['optimizer']
-        scheduler = self._optimization_parameters['lr_scheduler']
+        opt = self._optimization_parameters["optimizer"]
+        scheduler = self._optimization_parameters["lr_scheduler"]
         if scheduler is None:
             return opt
         return [opt], [scheduler]
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x)
 
@@ -444,26 +446,30 @@ def training_step(self, batch, *args, **kwargs): # noqa
         loss = self.loss(y_pred, y)
         for metric_name, metric in self._metrics:
             metric.update(y_pred, y)
-            self.log(metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(metric_name, self._to_out(metric.compute()).item(), prog_bar=True)
 
         return {
-            'loss': loss,
+            "loss": loss,
         }
 
-    def validation_step(self, batch, *args, **kwargs): # noqa
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self.net(x)
 
         # Compute metrics and loss.
         val_loss = self.loss(y_pred, y)
-        self.log('val_loss', val_loss.item(), prog_bar = True)
+        self.log("val_loss", val_loss.item(), prog_bar=True)
         for metric_name, metric in self._metrics:
             metric.to(self.device)
             metric.update(y_pred, y)
-            self.log('val_' + metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(
+                "val_" + metric_name,
+                self._to_out(metric.compute()).item(),
+                prog_bar=True,
+            )
 
         return {
-            'val_loss': val_loss,
+            "val_loss": val_loss,
         }
 
     def test_step(self, batch, *args, **kwargs):
@@ -472,19 +478,16 @@ def test_step(self, batch, *args, **kwargs):
 
         # Compute metrics and loss.
         test_loss = self.loss(y_pred, y)
-        self.log('test_loss', test_loss.item(), prog_bar = True)
+        self.log("test_loss", test_loss.item(), prog_bar=True)
         for metric_name, metric in self._metrics:
             metric.update(y_pred, y)
 
-            self.log('test_' + metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(
+                "test_" + metric_name,
+                self._to_out(metric.compute()).item(),
+                prog_bar=True,
+            )
 
         return {
-            'test_loss': test_loss,
+            "test_loss": test_loss,
         }
-
-
-
-
-
-
-
diff --git a/agml/models/legacy/detection_efficientdet.py b/agml/models/legacy/detection_efficientdet.py
index e88d9e5a..2edab0c0 100644
--- a/agml/models/legacy/detection_efficientdet.py
+++ b/agml/models/legacy/detection_efficientdet.py
@@ -14,11 +14,9 @@
 
 import warnings
 
-import numpy as np
 import albumentations as A
-
+import numpy as np
 import torch
-
 from tqdm import tqdm
 
 try:
@@ -30,12 +28,7 @@
     )
 
 try:
-    from effdet import (
-        create_model_from_config,
-        get_efficientdet_config,
-        DetBenchPredict,
-        DetBenchTrain
-    )
+    from effdet import DetBenchPredict, DetBenchTrain, create_model_from_config, get_efficientdet_config
 except ImportError:
     raise ImportError(
         "Could not find an installation of the `effdet` package. "
@@ -43,12 +36,12 @@
         "the version is important for proper functionality)."
     )
 
+from agml.backend.tftorch import is_array_like
+from agml.data.public import source
 from agml.models.base import AgMLModelBase
 from agml.models.benchmarks import BenchmarkMetadata
-from agml.models.tools import auto_move_data
 from agml.models.metrics.map import MeanAveragePrecision
-from agml.data.public import source
-from agml.backend.tftorch import is_array_like
+from agml.models.tools import auto_move_data
 from agml.utils.general import has_func
 from agml.utils.image import resolve_image_size
 from agml.utils.logging import log
@@ -91,23 +84,19 @@ class DetectionModel(AgMLModelBase):
     conf_threshold : float
         Filters bounding boxes by their level of confidence based on this threshold.
     """
-    serializable = frozenset((
-        "model", "num_classes", "conf_thresh", "image_size"))
+
+    serializable = frozenset(("model", "num_classes", "conf_thresh", "image_size"))
     state_override = frozenset(("model",))
 
-    _ml_task = 'object_detection'
+    _ml_task = "object_detection"
 
-    def __init__(self,
-                 num_classes = 1,
-                 image_size = 512,
-                 conf_threshold = 0.3,
-                 **kwargs):
+    def __init__(self, num_classes=1, image_size=512, conf_threshold=0.3, **kwargs):
         # Initialize the base modules.
         super(DetectionModel, self).__init__()
 
         # If being initialized by a subclass, then don't do any of
         # model construction logic (since that's already been done).
-        if not kwargs.get('model_initialized', False):
+        if not kwargs.get("model_initialized", False):
             # Construct the network and load in pretrained weights.
             self._image_size = resolve_image_size(image_size)
             self._confidence_threshold = conf_threshold
@@ -115,13 +104,12 @@ def __init__(self,
             self.model = self._construct_sub_net(
                 self._num_classes,
                 self._image_size,
-                pretrained = kwargs.get('pretrained', True))
+                pretrained=kwargs.get("pretrained", True),
+            )
 
         # Filter out unnecessary warnings.
-        warnings.filterwarnings(
-            'ignore', category = UserWarning, module = 'ensemble_boxes')
-        warnings.filterwarnings(
-            'ignore', category = UserWarning, module = 'effdet.bench')  # noqa
+        warnings.filterwarnings("ignore", category=UserWarning, module="ensemble_boxes")
+        warnings.filterwarnings("ignore", category=UserWarning, module="effdet.bench")  # noqa
 
     @auto_move_data
     def forward(self, *batch):
@@ -131,11 +119,10 @@ def forward(self, *batch):
         return self.model(batch[0])
 
     @staticmethod
-    def _construct_sub_net(num_classes, image_size, pretrained = False):
-        cfg = get_efficientdet_config('tf_efficientdet_d4')
+    def _construct_sub_net(num_classes, image_size, pretrained=False):
+        cfg = get_efficientdet_config("tf_efficientdet_d4")
         cfg.update({"image_size": image_size})
-        model = create_model_from_config(
-            cfg, pretrained = pretrained, num_classes = num_classes)
+        model = create_model_from_config(cfg, pretrained=pretrained, num_classes=num_classes)
         return DetBenchPredict(model)
 
     def switch_predict(self):
@@ -157,7 +144,7 @@ def original(self):  # override for detection models.
         return self.model.model
 
     @torch.jit.ignore()
-    def reset_class_net(self, num_classes = 1):
+    def reset_class_net(self, num_classes=1):
         """Reconfigures the output class net for a new number of classes.
 
         Parameters
@@ -166,7 +153,7 @@ def reset_class_net(self, num_classes = 1):
             The number of classes to reconfigure the output net to use.
         """
         if num_classes != self._num_classes:
-            self.model.model.reset_head(num_classes = num_classes)
+            self.model.model.reset_head(num_classes=num_classes)
 
     @staticmethod
     def _preprocess_image(image, image_size):
@@ -187,12 +174,12 @@ def _preprocess_image(image, image_size):
         dimension for two-channel inputs, for example.
         """
         # Convert the image to a NumPy array.
-        if is_array_like(image) and hasattr(image, 'numpy'):
+        if is_array_like(image) and hasattr(image, "numpy"):
             image = image.numpy()
 
         # Add a channel dimension for grayscale imagery.
         if image.ndim == 2:
-            image = np.expand_dims(image, axis = -1)
+            image = np.expand_dims(image, axis=-1)
 
         # If the image is already in channels-first format, convert
         # it back temporarily until preprocessing has concluded.
@@ -201,13 +188,13 @@ def _preprocess_image(image, image_size):
 
         # Resize the image to ImageNet standards.
         (w, h) = image_size
-        rz = A.Resize(height = h, width = w)
+        rz = A.Resize(height=h, width=w)
         if image.shape[0] != h or image.shape[1] != w:
-            image = rz(image = image)['image']
+            image = rz(image=image)["image"]
 
         # Normalize the image to ImageNet standards.
         if 1 <= image.max() <= 255:
-            image = image.astype(np.float32) / 255.
+            image = image.astype(np.float32) / 255.0
 
         # Convert the image into a PyTorch tensor.
         image = torch.from_numpy(image).permute(2, 0, 1)
@@ -216,7 +203,7 @@ def _preprocess_image(image, image_size):
         return image
 
     @torch.jit.ignore()
-    def preprocess_input(self, images, return_shapes = False):
+    def preprocess_input(self, images, return_shapes=False):
         """Preprocesses the input image to the specification of the model.
 
         This method takes in a set of inputs and preprocesses them into the
@@ -257,9 +244,7 @@ def preprocess_input(self, images, return_shapes = False):
         """
         images = self._expand_input_images(images)
         shapes = self._get_shapes(images)
-        images = torch.stack(
-            [self._preprocess_image(
-                image, self._image_size) for image in images], dim = 0)
+        images = torch.stack([self._preprocess_image(image, self._image_size) for image in images], dim=0)
         if return_shapes:
             return images, shapes
         return images
@@ -286,9 +271,7 @@ def _process_detections(self, detections):
 
         # Run weighted boxes fusion. For an exact description of how this
         # works, see the paper: https://arxiv.org/pdf/1910.13302.pdf.
-        (predicted_bboxes,
-         predicted_class_confidences,
-         predicted_class_labels) = self._wbf(predictions)
+        (predicted_bboxes, predicted_class_confidences, predicted_class_labels) = self._wbf(predictions)
         return predicted_bboxes, predicted_class_confidences, predicted_class_labels
 
     @staticmethod
@@ -299,7 +282,7 @@ def _rescale_bboxes(predicted_bboxes, image_sizes, yxyx=False):
             h, w = img_dims
             if len(bboxes) > 0:
                 # Move the device to the CPU.
-                if hasattr(bboxes, 'cpu'):
+                if hasattr(bboxes, "cpu"):
                     bboxes = bboxes.cpu()
 
                 # Re-scale the bounding box to the appropriate format.
@@ -331,9 +314,7 @@ def _wbf(predictions):
             labels = [prediction["classes"].tolist()]
 
             # Run the actual fusion and update the containers.
-            boxes, scores, labels = weighted_boxes_fusion(
-                boxes, scores, labels,
-                iou_thr = 0.44, skip_box_thr = 0.43)
+            boxes, scores, labels = weighted_boxes_fusion(boxes, scores, labels, iou_thr=0.44, skip_box_thr=0.43)
             boxes = boxes * (512 - 1)
             bboxes.append(boxes)
             confidences.append(scores)
@@ -343,14 +324,12 @@ def _wbf(predictions):
     @staticmethod
     def _remap_outputs(boxes, labels, confidences):
         """Remaps the outputs to the format described in `predict()`."""
-        squeeze = lambda *args: tuple(list(
-            np.squeeze(a).tolist() for a in args))
-        return [squeeze(b, l, c)
-                for b, l, c in zip(boxes, labels, confidences)]
+        squeeze = lambda *args: tuple(list(np.squeeze(a).tolist() for a in args))
+        return [squeeze(b, l, c) for b, l, c in zip(boxes, labels, confidences)]
 
     def _to_out(self, tensor: "torch.Tensor") -> "torch.Tensor":
         if isinstance(tensor, dict):
-            tensor = tensor['detections']
+            tensor = tensor["detections"]
         return super()._to_out(tensor)
 
     @torch.no_grad()
@@ -383,7 +362,7 @@ def predict(self, images):
         for the corresponding input image.
         """
         # Process the images and run inference.
-        images, shapes = self.preprocess_input(images, return_shapes = True)
+        images, shapes = self.preprocess_input(images, return_shapes=True)
         out = self._to_out(self.forward(images))
 
         # Post-process the output detections.
@@ -416,7 +395,7 @@ def show_prediction(self, image):
             bboxes, labels = [bboxes], [labels]
         return show_image_and_boxes(image, bboxes, labels)
 
-    def load_benchmark(self, dataset, strict = False):
+    def load_benchmark(self, dataset, strict=False):
         """Loads a benchmark for the given semantic segmentation dataset.
 
         This method is used to load pretrained weights for a specific AgML dataset.
@@ -439,11 +418,12 @@ def load_benchmark(self, dataset, strict = False):
         network weights (backbone, box network, etc.) will use the pretrained weights
         for the benchmark. This can be disabled by setting `strict = True`.
         """
-        if source(dataset).tasks.ml != 'object_detection':
+        if source(dataset).tasks.ml != "object_detection":
             raise ValueError(
                 f"You are trying to load a benchmark for a "
                 f"{source(dataset).tasks.ml} task ({dataset}) "
-                f"in an object detection model.")
+                f"in an object detection model."
+            )
 
         # Check loading strictness.
         cs = source(dataset).num_classes == self._num_classes
@@ -453,22 +433,25 @@ def load_benchmark(self, dataset, strict = False):
                     f"You cannot load a benchmark for a dataset '{dataset}' "
                     f"with {source(dataset).num_classes} classes, while your "
                     f"model has {self._num_classes} classes. If you want to, "
-                    f"then you need to set `strict = False`.")
+                    f"then you need to set `strict = False`."
+                )
 
         # Load the benchmark.
         state = self._get_benchmark(dataset)
         if not strict and not cs:
             self.reset_class_net(source(dataset).num_classes)
-            log(f"Loading a state dict for {dataset} with "
+            log(
+                f"Loading a state dict for {dataset} with "
                 f"{source(dataset).num_classes}, while your "
                 f"model has {self._num_classes} classes. The "
-                f"class network will use random weights.")
+                f"class network will use random weights."
+            )
         self.load_state_dict(state)
         if not strict and not cs:
             self.reset_class_net(self._num_classes)
         self._benchmark = BenchmarkMetadata(dataset)
 
-    def evaluate(self, loader, iou_threshold = 0.5, method = 'accumulate'):
+    def evaluate(self, loader, iou_threshold=0.5, method="accumulate"):
         """Runs a mean average precision evaluation on the given loader.
 
         This method will loop over the provided `AgMLDataLoader` and compute
@@ -493,57 +476,59 @@ def evaluate(self, loader, iou_threshold = 0.5, method = 'accumulate'):
         The final calculated mean average precision.
         """
         if not 0 < iou_threshold < 1:
-            raise ValueError(
-                f"The `iou_threshold` must be between 0 and 1, got {iou_threshold}.")
-        if method not in ['accumulate', 'average']:
-            raise ValueError(
-                f"Method must be either `accumulate` or `average`, got {method}.")
+            raise ValueError(f"The `iou_threshold` must be between 0 and 1, got {iou_threshold}.")
+        if method not in ["accumulate", "average"]:
+            raise ValueError(f"Method must be either `accumulate` or `average`, got {method}.")
 
         # Construct the mean average precision accumulator and run the calculations.
-        mean_ap = MeanAveragePrecision(
-            num_classes = self._num_classes, iou_threshold = iou_threshold)
-        bar = tqdm(loader, desc = "Calculating Mean Average Precision")
-        if method == 'average':
+        mean_ap = MeanAveragePrecision(num_classes=self._num_classes, iou_threshold=iou_threshold)
+        bar = tqdm(loader, desc="Calculating Mean Average Precision")
+        if method == "average":
             cumulative_maps = []
         for sample in bar:
             image, truth = sample
-            true_box, true_label = truth['bbox'], truth['category_id']
+            true_box, true_label = truth["bbox"], truth["category_id"]
             bboxes, labels, conf = self.predict(image)
-            mean_ap.update(*(
-                dict(boxes = bboxes, labels = labels, scores = conf),
-                dict(boxes = true_box, labels = true_label)))
+            mean_ap.update(
+                *(
+                    dict(boxes=bboxes, labels=labels, scores=conf),
+                    dict(boxes=true_box, labels=true_label),
+                )
+            )
 
             # If averaging, then calculate and reset the mAP, otherwise continue.
-            if method == 'average':
+            if method == "average":
                 res = mean_ap.compute()
-                cumulative_maps.append(res) # noqa
-                bar.set_postfix({'map': float(res)})
+                cumulative_maps.append(res)  # noqa
+                bar.set_postfix({"map": float(res)})
                 mean_ap.reset()
 
         # Compute the final mAP.
-        if method == 'average':
+        if method == "average":
             result = sum(cumulative_maps) / len(cumulative_maps)
         else:
             result = mean_ap.compute()
         return result
 
-    def run_training(self,
-                     dataset=None,
-                     *,
-                     epochs=50,
-                     metrics=None,
-                     optimizer=None,
-                     lr_scheduler=None,
-                     lr=None,
-                     batch_size=8,
-                     loggers=None,
-                     train_dataloader=None,
-                     val_dataloader=None,
-                     test_dataloader=None,
-                     use_cpu=False,
-                     save_dir=None,
-                     experiment_name=None,
-                     **kwargs):
+    def run_training(
+        self,
+        dataset=None,
+        *,
+        epochs=50,
+        metrics=None,
+        optimizer=None,
+        lr_scheduler=None,
+        lr=None,
+        batch_size=8,
+        loggers=None,
+        train_dataloader=None,
+        val_dataloader=None,
+        test_dataloader=None,
+        use_cpu=False,
+        save_dir=None,
+        experiment_name=None,
+        **kwargs,
+    ):
         """Trains an object detection model.
 
         This method can be used to train an object detection model on a given
@@ -632,27 +617,24 @@ def run_training(self,
 
         return train_detection(
             self,
-            dataset = dataset,
-            epochs = epochs,
-            metrics = metrics,
-            optimizer = optimizer,
-            lr_scheduler = lr_scheduler,
-            lr = lr,
+            dataset=dataset,
+            epochs=epochs,
+            metrics=metrics,
+            optimizer=optimizer,
+            lr_scheduler=lr_scheduler,
+            lr=lr,
             batch_size=batch_size,
-            loggers = loggers,
-            train_dataloader = train_dataloader,
-            val_dataloader = val_dataloader,
-            test_dataloader = test_dataloader,
-            use_cpu = use_cpu,
-            save_dir = save_dir,
-            experiment_name = experiment_name,
-            **kwargs
+            loggers=loggers,
+            train_dataloader=train_dataloader,
+            val_dataloader=val_dataloader,
+            test_dataloader=test_dataloader,
+            use_cpu=use_cpu,
+            save_dir=save_dir,
+            experiment_name=experiment_name,
+            **kwargs,
         )
 
-    def _prepare_for_training(self,
-                              metrics = (),
-                              optimizer = None,
-                              **kwargs):
+    def _prepare_for_training(self, metrics=(), optimizer=None, **kwargs):
         """Prepares the model for training."""
 
         # Initialize the metrics.
@@ -661,15 +643,16 @@ def _prepare_for_training(self,
             for metric in metrics:
                 # So far, only the mAP metric is supported.
                 if isinstance(metric, str):
-                    if metric.lower() not in ['ap', 'map']:
+                    if metric.lower() not in ["ap", "map"]:
                         raise ValueError(
                             "Unfortunately, the only currently supported metric "
                             "is mean average precision (use 'ap' or 'map' "
-                            "to enable mean average precision).")
+                            "to enable mean average precision)."
+                        )
 
                     self.map = MeanAveragePrecision(
-                        num_classes = self._num_classes,
-                        iou_threshold = kwargs.get('iou_threshold', 0.5)
+                        num_classes=self._num_classes,
+                        iou_threshold=kwargs.get("iou_threshold", 0.5),
                     )
 
         # Initialize the optimizer/learning rate scheduler.
@@ -678,36 +661,37 @@ def _prepare_for_training(self,
             if not has_func(torch.optim, optimizer_class):
                 raise ValueError(
                     f"Expected a valid optimizer name, but got '{optimizer_class}'. "
-                    f"Check `torch.optim` for a list of valid optimizers.")
+                    f"Check `torch.optim` for a list of valid optimizers."
+                )
 
             optimizer = getattr(torch.optim, optimizer_class)(
-                self.parameters(), lr = kwargs.get(
-                    'lr', 0.0002 if self._num_classes == 1 else 0.0008))
+                self.parameters(),
+                lr=kwargs.get("lr", 0.0002 if self._num_classes == 1 else 0.0008),
+            )
         elif isinstance(optimizer, torch.optim.Optimizer):
             pass  # nothing to do
         else:
-            raise TypeError(
-                f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
+            raise TypeError(f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
 
-        scheduler = kwargs.get('lr_scheduler', None)
+        scheduler = kwargs.get("lr_scheduler", None)
         if scheduler is not None:
             # No string auto-initialization, the LR scheduler must be pre-configured.
             if isinstance(scheduler, str):
                 raise ValueError(
                     f"If you want to use a learning rate scheduler, you must initialize "
-                    f"it on your own and pass it to the `lr_scheduler` argument. ")
+                    f"it on your own and pass it to the `lr_scheduler` argument. "
+                )
             elif not isinstance(scheduler, torch.optim.lr_scheduler.LRScheduler):
-                raise TypeError(
-                    f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
+                raise TypeError(f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
 
         self._optimization_parameters = {
-            'optimizer': optimizer,
-            'lr_scheduler': scheduler
+            "optimizer": optimizer,
+            "lr_scheduler": scheduler,
         }
 
     def configure_optimizers(self):
-        opt = self._optimization_parameters['optimizer']
-        scheduler = self._optimization_parameters['lr_scheduler']
+        opt = self._optimization_parameters["optimizer"]
+        scheduler = self._optimization_parameters["lr_scheduler"]
         if scheduler is None:
             return opt
         return [opt], [scheduler]
@@ -720,35 +704,50 @@ def training_step(self, batch, batch_idx, *args, **kwargs):
     def validation_step(self, batch, batch_idx, *args, **kwargs):
         images, annotations, targets = batch
         outputs = self(images, annotations)
-        detections = outputs['detections']
+        detections = outputs["detections"]
 
         # Calculate the mean average precision.
         if not self.trainer.sanity_checking and self.map is not None:
             boxes, confidences, labels = self._process_detections(self._to_out(detections))
-            if hasattr(boxes, 'cpu'):
+            if hasattr(boxes, "cpu"):
                 boxes = boxes.cpu()
-            if hasattr(annotations['bbox'], 'cpu'):
-                annotations['bbox'] = annotations['bbox'].cpu()
+            if hasattr(annotations["bbox"], "cpu"):
+                annotations["bbox"] = annotations["bbox"].cpu()
             boxes = self._rescale_bboxes(boxes, [[512, 512]] * len(images))
-            annotations['bbox'] = self._rescale_bboxes(
-                annotations['bbox'], [[512, 512, ]] * len(images), yxyx=True)
+            annotations["bbox"] = self._rescale_bboxes(
+                annotations["bbox"],
+                [
+                    [
+                        512,
+                        512,
+                    ]
+                ]
+                * len(images),
+                yxyx=True,
+            )
 
             for pred_box, pred_label, pred_conf, true_box, true_label in zip(
-                    boxes, labels, confidences, annotations['bbox'], annotations['cls']):
+                boxes, labels, confidences, annotations["bbox"], annotations["cls"]
+            ):
                 metric_update_values = (
-                    dict(boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
-                         labels=self._to_out(torch.tensor(pred_label, dtype=torch.int32)),
-                         scores=self._to_out(torch.tensor(pred_conf))),
-                    dict(boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
-                         labels=self._to_out(torch.tensor(true_label, dtype=torch.int32))))
+                    dict(
+                        boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
+                        labels=self._to_out(torch.tensor(pred_label, dtype=torch.int32)),
+                        scores=self._to_out(torch.tensor(pred_conf)),
+                    ),
+                    dict(
+                        boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
+                        labels=self._to_out(torch.tensor(true_label, dtype=torch.int32)),
+                    ),
+                )
                 self.map.update(*metric_update_values)
 
                 # Log the MAP values.
                 map_ = self.map.compute().detach().cpu().numpy().item()
                 self.log("val_map", map_, prog_bar=True, logger=True, sync_dist=True)
 
-        self.log("val_loss", outputs['loss'], prog_bar=True, logger=True, sync_dist=True)
-        return outputs['loss']
+        self.log("val_loss", outputs["loss"], prog_bar=True, logger=True, sync_dist=True)
+        return outputs["loss"]
 
     def on_validation_epoch_end(self):
         if self.map is not None:
@@ -760,36 +759,43 @@ def test_step(self, batch, batch_idx, *args, **kwargs):
 
         # Calculate the mean average precision.
         if not self.trainer.sanity_checking and self.map is not None:
-            boxes, confidences, labels = self._process_detections(self._to_out(outputs['detections']))
-            if hasattr(boxes, 'cpu'):
+            boxes, confidences, labels = self._process_detections(self._to_out(outputs["detections"]))
+            if hasattr(boxes, "cpu"):
                 boxes = boxes.cpu()
-            if hasattr(annotations['bbox'], 'cpu'):
-                annotations['bbox'] = annotations['bbox'].cpu()
+            if hasattr(annotations["bbox"], "cpu"):
+                annotations["bbox"] = annotations["bbox"].cpu()
             boxes = self._rescale_bboxes(boxes, [[512, 512]] * len(images))
-            annotations['bbox'] = self._rescale_bboxes(
-                annotations['bbox'], [[512, 512, ]] * len(images), yxyx=True)
+            annotations["bbox"] = self._rescale_bboxes(
+                annotations["bbox"],
+                [
+                    [
+                        512,
+                        512,
+                    ]
+                ]
+                * len(images),
+                yxyx=True,
+            )
 
             for pred_box, pred_label, pred_conf, true_box, true_label in zip(
-                    boxes, labels, confidences, annotations['bbox'], annotations['cls']):
+                boxes, labels, confidences, annotations["bbox"], annotations["cls"]
+            ):
                 metric_update_values = (
-                    dict(boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
-                         labels=self._to_out(torch.tensor(pred_label, dtype=torch.int32)),
-                         scores=self._to_out(torch.tensor(pred_conf))),
-                    dict(boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
-                         labels=self._to_out(torch.tensor(true_label, dtype=torch.int32))))
+                    dict(
+                        boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
+                        labels=self._to_out(torch.tensor(pred_label, dtype=torch.int32)),
+                        scores=self._to_out(torch.tensor(pred_conf)),
+                    ),
+                    dict(
+                        boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
+                        labels=self._to_out(torch.tensor(true_label, dtype=torch.int32)),
+                    ),
+                )
                 self.map.update(*metric_update_values)
 
                 # Log the MAP values.
                 map_ = self.map.compute().detach().cpu().numpy().item()
                 self.log("test_map", map_, prog_bar=True, logger=True, sync_dist=True)
 
-        self.log("test_loss", outputs['loss'], prog_bar=True, logger=True, sync_dist=True)
-        return outputs['loss']
-
-
-
-
-
-
-
-
+        self.log("test_loss", outputs["loss"], prog_bar=True, logger=True, sync_dist=True)
+        return outputs["loss"]
diff --git a/agml/models/legacy/segmentation_deeplab.py b/agml/models/legacy/segmentation_deeplab.py
index 456682ff..d4cfec40 100644
--- a/agml/models/legacy/segmentation_deeplab.py
+++ b/agml/models/legacy/segmentation_deeplab.py
@@ -13,32 +13,33 @@
 # limitations under the License.
 
 import numpy as np
-from tqdm import tqdm
-
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+from tqdm import tqdm
 
 try:
     from torchvision.models.segmentation import deeplabv3_resnet50
 except ImportError:
-    raise ImportError("To use image classification models in `agml.models`, you "
-                      "need to install Torchvision first. You can do this by "
-                      "running `pip install torchvision`.")
+    raise ImportError(
+        "To use image classification models in `agml.models`, you "
+        "need to install Torchvision first. You can do this by "
+        "running `pip install torchvision`."
+    )
+
+# This is last since `agml.models.base` will check for PyTorch Lightning,
+# and PyTorch Lightning automatically installed torchmetrics with it.
+from torchmetrics import JaccardIndex as IoU
 
+from agml.data.public import source
 from agml.models.base import AgMLModelBase
 from agml.models.benchmarks import BenchmarkMetadata
-from agml.models.tools import auto_move_data, imagenet_style_process
 from agml.models.losses import DiceLoss
-from agml.data.public import source
-from agml.utils.general import resolve_list_value, has_func
+from agml.models.tools import auto_move_data, imagenet_style_process
+from agml.utils.general import has_func, resolve_list_value
 from agml.utils.image import resolve_image_size
 from agml.utils.logging import log
-from agml.viz.masks import show_image_and_overlaid_mask, show_image_and_mask
-
-# This is last since `agml.models.base` will check for PyTorch Lightning,
-# and PyTorch Lightning automatically installed torchmetrics with it.
-from torchmetrics import JaccardIndex as IoU
+from agml.viz.masks import show_image_and_mask, show_image_and_overlaid_mask
 
 
 class DeepLabV3Transfer(nn.Module):
@@ -46,12 +47,10 @@ class DeepLabV3Transfer(nn.Module):
 
     def __init__(self, num_classes):
         super(DeepLabV3Transfer, self).__init__()
-        self.base = deeplabv3_resnet50(
-            pretrained=False,
-            num_classes=num_classes)
+        self.base = deeplabv3_resnet50(pretrained=False, num_classes=num_classes)
 
     def forward(self, x, **kwargs):  # noqa
-        return self.base(x)['out']
+        return self.base(x)["out"]
 
 
 class SegmentationModel(AgMLModelBase):
@@ -76,31 +75,26 @@ class SegmentationModel(AgMLModelBase):
     parameter `net`, and you'll need to implement methods like `training_step`,
     `configure_optimizers`, etc. See PyTorch Lightning for more information.
     """
-    serializable = frozenset((
-        "net", "num_classes", "conf_thresh", "image_size"))
+
+    serializable = frozenset(("net", "num_classes", "conf_thresh", "image_size"))
     state_override = frozenset(("net",))
 
-    _ml_task = 'semantic_segmentation'
+    _ml_task = "semantic_segmentation"
 
-    def __init__(self,
-                 num_classes=1,
-                 image_size=512,
-                 **kwargs):
+    def __init__(self, num_classes=1, image_size=512, **kwargs):
         # Construct the network and load in pretrained weights.
         super(SegmentationModel, self).__init__()
 
         # If being initialized by a subclass, then don't do any of
         # model construction logic (since that's already been done).
-        if not kwargs.get('model_initialized', False):
+        if not kwargs.get("model_initialized", False):
             self._num_classes = num_classes
             self._image_size = resolve_image_size(image_size)
             self.net = self._construct_sub_net(num_classes)
             if self._num_classes == 1:
-                conf_threshold = kwargs.get('conf_threshold', 0.2)
+                conf_threshold = kwargs.get("conf_threshold", 0.2)
                 if not 0 < conf_threshold < 1:
-                    raise ValueError(
-                        "The given confidence threshold "
-                        "must be between 0 and 1.")
+                    raise ValueError("The given confidence threshold " "must be between 0 and 1.")
                 self._conf_thresh = conf_threshold
 
         # By default, the model starts in inference mode.
@@ -176,8 +170,9 @@ def preprocess_input(self, images, return_shapes=False, **kwargs):
         images = self._expand_input_images(images)
         shapes = self._get_shapes(images)
         images = torch.stack(
-            [self._preprocess_image(
-                image, self._image_size, **kwargs) for image in images], dim=0)
+            [self._preprocess_image(image, self._image_size, **kwargs) for image in images],
+            dim=0,
+        )
         if return_shapes:
             return images, shapes
         return images
@@ -222,11 +217,17 @@ def predict(self, images, **kwargs):
 
         # Resize the masks to their original shapes.
         masks = []
-        for mask, shape in zip(
-                torch.index_select(out, 0, torch.arange(len(out))), shapes):
-            masks.append(self._to_out(torch.squeeze(F.interpolate(
-                torch.unsqueeze(torch.unsqueeze(mask, 0), 0).float(),
-                size=shape).int())))
+        for mask, shape in zip(torch.index_select(out, 0, torch.arange(len(out))), shapes):
+            masks.append(
+                self._to_out(
+                    torch.squeeze(
+                        F.interpolate(
+                            torch.unsqueeze(torch.unsqueeze(mask, 0), 0).float(),
+                            size=shape,
+                        ).int()
+                    )
+                )
+            )
         return resolve_list_value(masks)
 
     def show_prediction(self, image, overlay=False, **kwargs):
@@ -277,18 +278,20 @@ def load_benchmark(self, dataset):
         If the benchmark has a different number of classes than this input model, then
         this method will raise an error. This issue may be adapted in the future.
         """
-        if source(dataset).tasks.ml != 'semantic_segmentation':
+        if source(dataset).tasks.ml != "semantic_segmentation":
             raise ValueError(
                 f"You are trying to load a benchmark for a "
                 f"{source(dataset).tasks.ml} task ({dataset}) "
-                f"in a semantic segmentation model.")
+                f"in a semantic segmentation model."
+            )
 
         # Number of classes must be the same for semantic segmentation.
         if source(dataset).num_classes != self._num_classes:
             raise ValueError(
                 f"You cannot load a benchmark for a dataset '{dataset}' "
                 f"with {source(dataset).num_classes} classes, while your "
-                f"model has {self._num_classes} classes.")
+                f"model has {self._num_classes} classes."
+            )
 
         # Load the benchmark.
         state = self._get_benchmark(dataset)
@@ -319,31 +322,35 @@ def evaluate(self, loader, **kwargs):
             if pred_mask.ndim == 3:
                 pred_mask = np.transpose(pred_mask, (2, 0, 1))
                 truth = np.transpose(truth, (2, 0, 1))
-            iou(torch.from_numpy(pred_mask).int().unsqueeze(0),
-                torch.from_numpy(truth).unsqueeze(0))
-            bar.set_postfix({'miou': iou.compute().numpy().item()})
+            iou(
+                torch.from_numpy(pred_mask).int().unsqueeze(0),
+                torch.from_numpy(truth).unsqueeze(0),
+            )
+            bar.set_postfix({"miou": iou.compute().numpy().item()})
 
         # Compute the final mIoU.
         return iou.compute().numpy().item()
 
-    def run_training(self,
-                     dataset=None,
-                     *,
-                     epochs=50,
-                     loss=None,
-                     metrics=None,
-                     optimizer=None,
-                     lr_scheduler=None,
-                     lr=None,
-                     batch_size=8,
-                     loggers=None,
-                     train_dataloader=None,
-                     val_dataloader=None,
-                     test_dataloader=None,
-                     use_cpu=False,
-                     save_dir=None,
-                     experiment_name=None,
-                     **kwargs):
+    def run_training(
+        self,
+        dataset=None,
+        *,
+        epochs=50,
+        loss=None,
+        metrics=None,
+        optimizer=None,
+        lr_scheduler=None,
+        lr=None,
+        batch_size=8,
+        loggers=None,
+        train_dataloader=None,
+        val_dataloader=None,
+        test_dataloader=None,
+        use_cpu=False,
+        save_dir=None,
+        experiment_name=None,
+        **kwargs,
+    ):
         """Trains a semantic segmentation model.
 
         This method can be used to train a semantic segmentation model on a given
@@ -448,31 +455,26 @@ def run_training(self,
             use_cpu=use_cpu,
             save_dir=save_dir,
             experiment_name=experiment_name,
-            **kwargs
+            **kwargs,
         )
 
-    def _prepare_for_training(self,
-                              loss='ce',
-                              metrics=(),
-                              optimizer=None,
-                              **kwargs):
+    def _prepare_for_training(self, loss="ce", metrics=(), optimizer=None, **kwargs):
         """Prepares the model for training."""
 
         # Initialize the loss
-        if loss == 'ce':
+        if loss == "ce":
             # either binary or multiclass, binary is likely never used
             if self._num_classes == 1:
                 self.loss = nn.BCEWithLogitsLoss()
             else:
                 self.loss = nn.CrossEntropyLoss()
-        elif loss == 'dice':
+        elif loss == "dice":
             if self._num_classes == 1:
                 log("Dice loss is not necessarily supported for binary classification.")
             self.loss = DiceLoss()
         else:
             if not isinstance(loss, nn.Module) or not callable(loss):
-                raise TypeError(
-                    f"Expected a callable loss function, but got '{type(loss)}'.")
+                raise TypeError(f"Expected a callable loss function, but got '{type(loss)}'.")
 
         # Initialize the metrics.
         metric_collection = []
@@ -486,26 +488,33 @@ def _prepare_for_training(self,
                         raise ImportError(
                             "Received the name of a metric. If you want to use named "
                             "metrics, then you need to have `torchmetrics` installed. "
-                            "You can do this by running `pip install torchmetrics`.")
+                            "You can do this by running `pip install torchmetrics`."
+                        )
 
                     # Check if `torchmetrics.classification` has the metric.
                     if has_func(class_metrics, metric):
                         # iou/miou is a special case
-                        if metric == 'iou' or metric == 'miou':
+                        if metric == "iou" or metric == "miou":
                             metric_collection.append(
-                                [metric, IoU(
-                                    task='multiclass' if self._num_classes > 1 else 'binary',  # noqa
-                                    num_classes=self._num_classes + 1)])
+                                [
+                                    metric,
+                                    IoU(
+                                        task="multiclass" if self._num_classes > 1 else "binary",  # noqa
+                                        num_classes=self._num_classes + 1,
+                                    ),
+                                ]
+                            )
 
                         # convert to camel case
                         else:
-                            metric = ''.join([word.capitalize() for word in metric.split('_')])
+                            metric = "".join([word.capitalize() for word in metric.split("_")])
                             metric_collection.append([metric, getattr(class_metrics, metric)()])
                     else:
                         raise ValueError(
                             f"Expected a valid metric torchmetrics metric name, "
                             f"but got '{metric}'. Check `torchmetrics.classification` "
-                            f"for a list of valid image classification metrics.")
+                            f"for a list of valid image classification metrics."
+                        )
 
                 # Check if it is any other class.
                 elif isinstance(metric, nn.Module):
@@ -513,8 +522,7 @@ def _prepare_for_training(self,
 
                 # Otherwise, raise an error.
                 else:
-                    raise TypeError(
-                        f"Expected a metric name or a metric class, but got '{type(metric)}'.")
+                    raise TypeError(f"Expected a metric name or a metric class, but got '{type(metric)}'.")
         self._metrics = metric_collection
 
         # Initialize the optimizer/learning rate scheduler.
@@ -523,35 +531,34 @@ def _prepare_for_training(self,
             if not has_func(torch.optim, optimizer_class):
                 raise ValueError(
                     f"Expected a valid optimizer name, but got '{optimizer_class}'. "
-                    f"Check `torch.optim` for a list of valid optimizers.")
+                    f"Check `torch.optim` for a list of valid optimizers."
+                )
 
-            optimizer = getattr(torch.optim, optimizer_class)(
-                self.parameters(), lr=kwargs.get('lr', 2e-3))
+            optimizer = getattr(torch.optim, optimizer_class)(self.parameters(), lr=kwargs.get("lr", 2e-3))
         elif isinstance(optimizer, torch.optim.Optimizer):
             pass  # nothing to do
         else:
-            raise TypeError(
-                f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
+            raise TypeError(f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
 
-        scheduler = kwargs.get('lr_scheduler', None)
+        scheduler = kwargs.get("lr_scheduler", None)
         if scheduler is not None:
             # No string auto-initialization, the LR scheduler must be pre-configured.
             if isinstance(scheduler, str):
                 raise ValueError(
                     f"If you want to use a learning rate scheduler, you must initialize "
-                    f"it on your own and pass it to the `lr_scheduler` argument. ")
+                    f"it on your own and pass it to the `lr_scheduler` argument. "
+                )
             elif not isinstance(scheduler, torch.optim.lr_scheduler.LRScheduler):
-                raise TypeError(
-                    f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
+                raise TypeError(f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
 
         self._optimization_parameters = {
-            'optimizer': optimizer,
-            'lr_scheduler': scheduler
+            "optimizer": optimizer,
+            "lr_scheduler": scheduler,
         }
 
     def configure_optimizers(self):
-        opt = self._optimization_parameters['optimizer']
-        scheduler = self._optimization_parameters['lr_scheduler']
+        opt = self._optimization_parameters["optimizer"]
+        scheduler = self._optimization_parameters["lr_scheduler"]
         if scheduler is None:
             return opt
         return [opt], [scheduler]
@@ -568,7 +575,7 @@ def training_step(self, batch, *args, **kwargs):  # noqa
             self.log(metric_name, self._to_out(metric.compute()).item(), prog_bar=True)
 
         return {
-            'loss': loss,
+            "loss": loss,
         }
 
     def validation_step(self, batch, *args, **kwargs):  # noqa
@@ -578,14 +585,18 @@ def validation_step(self, batch, *args, **kwargs):  # noqa
 
         # Compute metrics and loss.
         val_loss = self.loss(y_pred, y)
-        self.log('val_loss', val_loss.item(), prog_bar=True)
+        self.log("val_loss", val_loss.item(), prog_bar=True)
         for metric_name, metric in self._metrics:
             metric.to(self.device)
             metric.update(y_pred, y)
-            self.log('val_' + metric_name, self._to_out(metric.compute()).item(), prog_bar=True)
+            self.log(
+                "val_" + metric_name,
+                self._to_out(metric.compute()).item(),
+                prog_bar=True,
+            )
 
         return {
-            'val_loss': val_loss,
+            "val_loss": val_loss,
         }
 
     def test_step(self, batch, *args, **kwargs):
@@ -595,14 +606,16 @@ def test_step(self, batch, *args, **kwargs):
 
         # Compute metrics and loss.
         test_loss = self.loss(y_pred, y)
-        self.log('test_loss', test_loss.item(), prog_bar=True)
+        self.log("test_loss", test_loss.item(), prog_bar=True)
         for metric_name, metric in self._metrics:
             metric.update(y_pred, y)
 
-            self.log('test_' + metric_name, self._to_out(metric.compute()).item(), prog_bar=True)
+            self.log(
+                "test_" + metric_name,
+                self._to_out(metric.compute()).item(),
+                prog_bar=True,
+            )
 
         return {
-            'test_loss': test_loss,
+            "test_loss": test_loss,
         }
-
-
diff --git a/agml/models/losses.py b/agml/models/losses.py
index ab5c6e56..fd6da906 100644
--- a/agml/models/losses.py
+++ b/agml/models/losses.py
@@ -35,7 +35,8 @@ def dice_loss(y_pred, y):
     try:  # Multi-class segmentation
         c, h, w = y.shape[1:]
     except:  # Binary segmentation
-        h, w = y.shape[1:]; c = 1 # noqa
+        h, w = y.shape[1:]
+        c = 1  # noqa
 
     # Sigmoid for the outputs (since this is automatically done by binary
     # cross-entropy loss with logits, the actual base model for semantic
@@ -46,13 +47,11 @@ def dice_loss(y_pred, y):
     # Run the dice loss calculations.
     pred_flat = torch.reshape(y_pred, [-1, c * h * w])
     y_flat = torch.reshape(y, [-1, c * h * w])
-    intersection = 2.0 * torch.sum(pred_flat * y_flat, dim = 1) + 1e-6
-    denominator = (torch.sum(pred_flat, dim = 1)
-                   + torch.sum(y_flat, dim = 1) + 1e-6)
-    return 1. - torch.mean(intersection / denominator)
+    intersection = 2.0 * torch.sum(pred_flat * y_flat, dim=1) + 1e-6
+    denominator = torch.sum(pred_flat, dim=1) + torch.sum(y_flat, dim=1) + 1e-6
+    return 1.0 - torch.mean(intersection / denominator)
 
 
 class DiceLoss(nn.Module):
-    def forward(self, x, target, **kwargs): # noqa
+    def forward(self, x, target, **kwargs):  # noqa
         return dice_loss(x, target)
-
diff --git a/agml/models/metrics/__init__.py b/agml/models/metrics/__init__.py
index 7da515a7..dc4597ea 100644
--- a/agml/models/metrics/__init__.py
+++ b/agml/models/metrics/__init__.py
@@ -12,12 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .map import (
-    mean_average_precision,
-    MeanAveragePrecision
-)
-from .accuracy import (
-    accuracy,
-    Accuracy
-)
-
+from .accuracy import Accuracy, accuracy
+from .map import MeanAveragePrecision, mean_average_precision
diff --git a/agml/models/metrics/accuracy.py b/agml/models/metrics/accuracy.py
index b2b69a2f..38357016 100644
--- a/agml/models/metrics/accuracy.py
+++ b/agml/models/metrics/accuracy.py
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import numpy as np
-
 import torch
 import torch.nn as nn
 
@@ -25,7 +24,7 @@ def accuracy(output, target):
     _, pred = torch.topk(output, 1, 1)
     pred = pred.t()
     correct = pred.eq(target.view(1, -1).expand_as(pred))
-    correct_k = correct[:1].reshape(-1).float().sum(0, keepdim = True)
+    correct_k = correct[:1].reshape(-1).float().sum(0, keepdim=True)
     return correct_k.div_(batch_size)
 
 
@@ -65,11 +64,9 @@ def update(self, pred_data, gt_data):
 
     def compute(self):
         """Computes the accuracy between the predictions and ground truths."""
-        return accuracy(torch.stack(self._prediction_data),
-                        torch.stack(self._truth_data))
+        return accuracy(torch.stack(self._prediction_data), torch.stack(self._truth_data))
 
     def reset(self):
         """Resets the accumulator states."""
         del self._prediction_data, self._truth_data
         self._prediction_data, self._truth_data = [], []
-
diff --git a/agml/models/metrics/map.py b/agml/models/metrics/map.py
index c628c60e..5747419b 100644
--- a/agml/models/metrics/map.py
+++ b/agml/models/metrics/map.py
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import numpy as np
-
 import torch
 import torch.nn as nn
 
@@ -41,15 +40,14 @@ def bbox_iou(predicted_box, truth_box):
     intersection = (x2 - x1).clamp(0) * (y2 - y1).clamp(0)
     box1_area = abs((box1_x2 - box1_x1) * (box1_y2 - box1_y1))
     box2_area = abs((box2_x2 - box2_x1) * (box2_y2 - box2_y1))
-    union_area = (box1_area + box2_area - intersection)
+    union_area = box1_area + box2_area - intersection
 
     # Return the intersection over union.
     return intersection / (union_area + 1e-6)
 
 
 @torch.no_grad()
-def mean_average_precision(
-        predicted_boxes, truth_boxes, num_classes = 1, iou_thresh = 0.5):
+def mean_average_precision(predicted_boxes, truth_boxes, num_classes=1, iou_thresh=0.5):
     """Calculates the mean average precision for predicted and true boxes."""
     average_precisions = []
 
@@ -80,11 +78,12 @@ def mean_average_precision(
 
         # Determine the number of boxes for each of the training samples.
         numpy_gt = torch.tensor(ground_truths)
-        amount_bboxes = {int(k.numpy().item()): torch.zeros(v) for k, v in zip(
-            *torch.unique(numpy_gt[:, 0], return_counts = True))}
+        amount_bboxes = {
+            int(k.numpy().item()): torch.zeros(v) for k, v in zip(*torch.unique(numpy_gt[:, 0], return_counts=True))
+        }
 
         # Sort the boxes by probabilities.
-        detections.sort(key = lambda x: x[2], reverse = True)
+        detections.sort(key=lambda x: x[2], reverse=True)
         tp = torch.zeros((len(detections)))
         fp = torch.zeros((len(detections)))
         total_true_bboxes = len(ground_truths)
@@ -100,20 +99,17 @@ def mean_average_precision(
 
             # Only take out the ground_truths that have the same
             # training idx as the detection.
-            ground_truth_img = torch_gt[
-                torch.where(torch_gt[:, 0] == update_num)[0]]
+            ground_truth_img = torch_gt[torch.where(torch_gt[:, 0] == update_num)[0]]
 
             # Get the bounding box with the highest IoU.
-            ious = torch.tensor([bbox_iou(
-                torch.tensor(detection[3:]), gt[3:].clone())
-                for gt in ground_truth_img])
+            ious = torch.tensor([bbox_iou(torch.tensor(detection[3:]), gt[3:].clone()) for gt in ground_truth_img])
 
             # If there are no ground truths for this image, then
             # this is a false positive.
             if len(ious) == 0:
                 fp[detection_idx] = 1
                 continue
-            
+
             best_iou = torch.max(ious)
             best_gt_idx = torch.argmax(ious)
 
@@ -137,9 +133,9 @@ def mean_average_precision(
                 fp[detection_idx] = 1
 
         # Calculate the prediction/recalls and update the array.
-        tp_cumsum = torch.cumsum(tp, dim = 0)
+        tp_cumsum = torch.cumsum(tp, dim=0)
         recalls = tp_cumsum / (total_true_bboxes + 1e-6)
-        precisions = tp_cumsum / (tp_cumsum + torch.cumsum(fp, dim = 0) + 1e-6)
+        precisions = tp_cumsum / (tp_cumsum + torch.cumsum(fp, dim=0) + 1e-6)
         precisions = torch.cat((torch.tensor([1]), precisions))
         recalls = torch.cat((torch.tensor([0]), recalls))
         average_precisions.append(torch.trapz(precisions, recalls))
@@ -158,7 +154,7 @@ class MeanAveragePrecision(nn.Module):
     the accumulators to an empty state, allowing from-scratch calculations.
     """
 
-    def __init__(self, num_classes = 1, iou_threshold = 0.5):
+    def __init__(self, num_classes=1, iou_threshold=0.5):
         # Set base parameters.
         super(MeanAveragePrecision, self).__init__()
         self._num_classes = num_classes
@@ -189,13 +185,15 @@ def update(self, pred_data, gt_data):
         """
         # Get the relevant data from the input arguments.
         if isinstance(pred_data, dict):
-            pred_boxes, pred_labels, pred_scores = \
-                pred_data['boxes'], pred_data['labels'], pred_data['scores']
+            pred_boxes, pred_labels, pred_scores = (
+                pred_data["boxes"],
+                pred_data["labels"],
+                pred_data["scores"],
+            )
         else:
             pred_boxes, pred_labels, pred_scores = pred_data
         if isinstance(gt_data, dict):
-            gt_boxes, gt_labels = \
-                gt_data['boxes'], gt_data['labels']
+            gt_boxes, gt_labels = gt_data["boxes"], gt_data["labels"]
         else:
             gt_boxes, gt_labels = gt_data
 
@@ -203,23 +201,20 @@ def update(self, pred_data, gt_data):
         pred_boxes = np.squeeze(pred_boxes)
         pred_labels = np.squeeze(pred_labels)
         pred_scores = np.squeeze(pred_scores)
-        pred_labels, gt_labels, pred_scores = \
-            self._scalar_to_array(pred_labels, gt_labels, pred_scores)
+        pred_labels, gt_labels, pred_scores = self._scalar_to_array(pred_labels, gt_labels, pred_scores)
         gt_boxes = np.squeeze(gt_boxes)
         if pred_boxes.ndim == 1:
-            pred_boxes = np.expand_dims(pred_boxes, axis = 0)
+            pred_boxes = np.expand_dims(pred_boxes, axis=0)
         if gt_boxes.ndim == 1:
-            gt_boxes = np.expand_dims(gt_boxes, axis = 0)
+            gt_boxes = np.expand_dims(gt_boxes, axis=0)
 
         # Create the data in the proper format.
         for bbox, label in zip(gt_boxes, gt_labels):
-            self._truth_data.append(
-                [self._num_updates, int(label - 1), 1.0, *bbox])
+            self._truth_data.append([self._num_updates, int(label - 1), 1.0, *bbox])
         if pred_boxes.ndim == 1:
-            pred_boxes = np.expand_dims(pred_boxes, axis = 0)
+            pred_boxes = np.expand_dims(pred_boxes, axis=0)
         for bbox, label, score in zip(pred_boxes, pred_labels, pred_scores):
-            self._prediction_data.append(
-                [self._num_updates, int(label - 1), score, *bbox])
+            self._prediction_data.append([self._num_updates, int(label - 1), score, *bbox])
 
         # Increment the number of updates.
         self._num_updates += 1
@@ -227,19 +222,18 @@ def update(self, pred_data, gt_data):
     def compute(self):
         """Computes the mean average precision with the given data."""
         if self._num_updates == 0:
-            log("Tried to compute mean average precision "
-                "without any data updates; returning 0.0.")
+            log("Tried to compute mean average precision " "without any data updates; returning 0.0.")
             return 0.0
 
         return mean_average_precision(
-            predicted_boxes = self._prediction_data,
-            truth_boxes = self._truth_data,
-            num_classes = self._num_classes,
-            iou_thresh = self._iou_threshold,
+            predicted_boxes=self._prediction_data,
+            truth_boxes=self._truth_data,
+            num_classes=self._num_classes,
+            iou_thresh=self._iou_threshold,
         )
 
     def reset(self):
         """Resets the mean average precision."""
         del self._prediction_data, self._truth_data
         self._prediction_data, self._truth_data = [], []
-        self._num_updates = 0
\ No newline at end of file
+        self._num_updates = 0
diff --git a/agml/models/preprocessing.py b/agml/models/preprocessing.py
index 327814f6..5d36a7a6 100644
--- a/agml/models/preprocessing.py
+++ b/agml/models/preprocessing.py
@@ -18,15 +18,15 @@
 
 import inspect
 
-import torch
+import albumentations as A
 import numpy as np
+import torch
 from PIL import Image
-import albumentations as A
 
 from agml.models.tools import imagenet_style_process as _isp
 
 
-def imagenet_preprocess(image, size = None):
+def imagenet_preprocess(image, size=None):
     """Preprocesses a single input image to ImageNet standards.
 
     The preprocessing steps are applied logically; if the images
@@ -43,26 +43,26 @@ def imagenet_preprocess(image, size = None):
     as well as other intermediate steps such as adding a channel
     dimension for two-channel inputs, for example.
     """
-    return _isp(image, size = size)
+    return _isp(image, size=size)
 
 
 class EfficientDetPreprocessor(object):
     """A preprocessor which prepares a data sample for `EfficientDet`.
-    
+
     This class can be used to construct a preprocessing pipeline which
     auto-formats the data in an `AgMLDataLoader` for object detection into
     the format necessary for training an `EfficientDet` model. By default,
     this includes resizing images, converting bounding boxes to `yxyx`, and
     finally preparing the image and annotation for PyTorch.
-    
+
     Using this class supersedes the need for any other transformations or
     even image resizing. It can be used as follows:
-    
+
     > loader = agml.data.AgMLDataLoader('grape_detection_californiaday')
     > processor = agml.models.EfficientDetPreprocessor(
     >     image_size = 512, augmentation = [A.HorizontalFlip(0.5)])
     > loader.transform(dual_transform = processor)
-    
+
     Parameters
     ----------
     image_size : int
@@ -72,7 +72,7 @@ class EfficientDetPreprocessor(object):
         into a Compose object), or a custom method which accepts three
         arguments: `image`, `bboxes`, and `labels`, and returns the same.
         The `bboxes` will be in the XYXY format.
-    
+
     Notes
     -----
     - Passing `augmentation = None`, the default, is equivalent to preparing
@@ -82,7 +82,7 @@ class EfficientDetPreprocessor(object):
       first dimension being the image's channels, for example).
     """
 
-    def __init__(self, image_size = 512, augmentation = None):
+    def __init__(self, image_size=512, augmentation=None):
         # Parse the image size.
         if isinstance(image_size, int):
             image_size = (image_size, image_size)
@@ -90,25 +90,30 @@ def __init__(self, image_size = 512, augmentation = None):
             if not len(image_size) == 2:
                 raise ValueError(
                     "Expected either an integer or sequence of 2 values "
-                    "for `image_size`, instead got ({image_size}).")
+                    "for `image_size`, instead got ({image_size})."
+                )
 
         # Construct the applied input augmentation.
         self._albumentations_params = dict(
-            bbox_params = A.BboxParams(
-                format = "pascal_voc", min_area = 0,
-                min_visibility = 0, label_fields = ["labels"]),
-            standard_augmentations = [
-                A.Resize(height = image_size[0],
-                         width = image_size[1], p = 1)])
+            bbox_params=A.BboxParams(
+                format="pascal_voc",
+                min_area=0,
+                min_visibility=0,
+                label_fields=["labels"],
+            ),
+            standard_augmentations=[A.Resize(height=image_size[0], width=image_size[1], p=1)],
+        )
         self._check_and_make_augmentation(augmentation)
 
     def _check_and_make_augmentation(self, augmentation):
         """Constructs the applied augmentation from the inputs."""
         # If no augmentation is provided, then use the defaults.
         if augmentation is None:
-            self._augmentation = A.Compose([
-                *self._albumentations_params['standard_augmentations']
-            ], p = 1.0, bbox_params = self._albumentations_params['bbox_params'])
+            self._augmentation = A.Compose(
+                [*self._albumentations_params["standard_augmentations"]],
+                p=1.0,
+                bbox_params=self._albumentations_params["bbox_params"],
+            )
 
         # If a list of augmentations are provided, then use those augmentations
         # wrapped alongside the default ones in a `Compose` object.
@@ -117,10 +122,13 @@ def _check_and_make_augmentation(self, augmentation):
                 raise ValueError(
                     "If providing a list of transforms, all of them must be "
                     f"albumentations augmentations, instead got {augmentation} "
-                    f"of types {[type(i) for i in augmentation]}.")
-            self._augmentation = A.Compose([
-                *augmentation, *self._albumentations_params['standard_augmentations']
-            ], p = 1.0, bbox_params = self._albumentations_params['bbox_params'])
+                    f"of types {[type(i) for i in augmentation]}."
+                )
+            self._augmentation = A.Compose(
+                [*augmentation, *self._albumentations_params["standard_augmentations"]],
+                p=1.0,
+                bbox_params=self._albumentations_params["bbox_params"],
+            )
 
         # Otherwise, the augmentation should be a method with three input
         # arguments, so check it and then wrap it into an application method.
@@ -128,45 +136,47 @@ def _check_and_make_augmentation(self, augmentation):
             if not len(inspect.signature(augmentation).parameters):
                 raise ValueError(
                     f"The input augmentation should have three input arguments, "
-                    f"instead got {inspect.signature(augmentation).parameters}.")
+                    f"instead got {inspect.signature(augmentation).parameters}."
+                )
             self._method_augmentation = augmentation
             self._augmentation = self._apply_method_augmentation
 
     def _apply_method_augmentation(self, image, bboxes, labels):
         # Wrapper method to apply a user-provided method augmentation.
         image, bboxes, labels = self._method_augmentation(image, bboxes, labels)
-        return {'image': image, 'bboxes': bboxes, 'labels': labels}
+        return {"image": image, "bboxes": bboxes, "labels": labels}
 
     def __call__(self, image, annotation):
         # Convert the image type.
         image = Image.fromarray(image)
 
         # Clip the bounding boxes to the image shape to prevent errors.
-        bboxes = np.array(annotation['bbox']).astype(np.int32)
+        bboxes = np.array(annotation["bbox"]).astype(np.int32)
         x_min = bboxes[:, 0]
         y_min = bboxes[:, 1]
         x_max = bboxes[:, 2] + x_min
         y_max = bboxes[:, 3] + y_min
-        x_min, y_min = np.clip(x_min, 0, image.width), \
-                       np.clip(y_min, 0, image.height)
-        x_max, y_max = np.clip(x_max, 0, image.width), \
-                       np.clip(y_max, 0, image.height)
+        x_min, y_min = np.clip(x_min, 0, image.width), np.clip(y_min, 0, image.height)
+        x_max, y_max = np.clip(x_max, 0, image.width), np.clip(y_max, 0, image.height)
 
         # Reconstruct the boxes and get the class labels.
-        bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis = 0)
-        class_labels = np.array(annotation['category_id']).squeeze()
+        bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis=0)
+        class_labels = np.array(annotation["category_id"]).squeeze()
 
         # Add an extra dimension to labels for consistency.
         if class_labels.ndim == 0:
-            class_labels = np.expand_dims(class_labels, axis = 0)
+            class_labels = np.expand_dims(class_labels, axis=0)
 
         # Add an albumentations augmentation.
-        sample = {'image': np.array(image, dtype = np.float32),
-                  'bboxes': bboxes, 'labels': class_labels}
+        sample = {
+            "image": np.array(image, dtype=np.float32),
+            "bboxes": bboxes,
+            "labels": class_labels,
+        }
         sample = self._augmentation(**sample)
-        image = sample['image']
-        bboxes = np.array(sample['bboxes'])
-        labels = sample['labels']
+        image = sample["image"]
+        bboxes = np.array(sample["bboxes"])
+        labels = sample["labels"]
 
         # Convert the image to a tensor.
         image = torch.from_numpy(image).permute(2, 0, 1)
@@ -185,16 +195,14 @@ def __call__(self, image, annotation):
         # Convert to yxyx from xyxy.
         _, new_h, new_w = image.shape
         if bboxes.ndim == 1:
-            bboxes = np.expand_dims(bboxes, axis = 0)
+            bboxes = np.expand_dims(bboxes, axis=0)
         bboxes[:, [0, 1, 2, 3]] = bboxes[:, [1, 0, 3, 2]]
 
         # Create the target from the annotations.
         target = {
-            "bboxes": torch.as_tensor(
-                bboxes, dtype = torch.float32).contiguous(),
+            "bboxes": torch.as_tensor(bboxes, dtype=torch.float32).contiguous(),
             "labels": torch.as_tensor(labels).contiguous(),
             "img_size": torch.tensor([new_h, new_w]).contiguous(),
-            "img_scale": torch.tensor([1.0]).contiguous()}
+            "img_scale": torch.tensor([1.0]).contiguous(),
+        }
         return image, target
-
-
diff --git a/agml/models/segmentation.py b/agml/models/segmentation.py
index f4b73f7c..d4cfec40 100644
--- a/agml/models/segmentation.py
+++ b/agml/models/segmentation.py
@@ -13,44 +13,44 @@
 # limitations under the License.
 
 import numpy as np
-from tqdm import tqdm
-
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+from tqdm import tqdm
 
 try:
     from torchvision.models.segmentation import deeplabv3_resnet50
 except ImportError:
-    raise ImportError("To use image classification models in `agml.models`, you "
-                      "need to install Torchvision first. You can do this by "
-                      "running `pip install torchvision`.")
+    raise ImportError(
+        "To use image classification models in `agml.models`, you "
+        "need to install Torchvision first. You can do this by "
+        "running `pip install torchvision`."
+    )
 
+# This is last since `agml.models.base` will check for PyTorch Lightning,
+# and PyTorch Lightning automatically installed torchmetrics with it.
+from torchmetrics import JaccardIndex as IoU
+
+from agml.data.public import source
 from agml.models.base import AgMLModelBase
 from agml.models.benchmarks import BenchmarkMetadata
-from agml.models.tools import auto_move_data, imagenet_style_process
 from agml.models.losses import DiceLoss
-from agml.data.public import source
-from agml.utils.general import resolve_list_value, has_func
+from agml.models.tools import auto_move_data, imagenet_style_process
+from agml.utils.general import has_func, resolve_list_value
 from agml.utils.image import resolve_image_size
 from agml.utils.logging import log
-from agml.viz.masks import show_image_and_overlaid_mask, show_image_and_mask
-
-# This is last since `agml.models.base` will check for PyTorch Lightning,
-# and PyTorch Lightning automatically installed torchmetrics with it.
-from torchmetrics import JaccardIndex as IoU
+from agml.viz.masks import show_image_and_mask, show_image_and_overlaid_mask
 
 
 class DeepLabV3Transfer(nn.Module):
     """Wraps a DeepLabV3 model with the right number of classes."""
+
     def __init__(self, num_classes):
         super(DeepLabV3Transfer, self).__init__()
-        self.base = deeplabv3_resnet50(
-            pretrained = False,
-            num_classes = num_classes)
-        
-    def forward(self, x, **kwargs): # noqa
-        return self.base(x)['out']
+        self.base = deeplabv3_resnet50(pretrained=False, num_classes=num_classes)
+
+    def forward(self, x, **kwargs):  # noqa
+        return self.base(x)["out"]
 
 
 class SegmentationModel(AgMLModelBase):
@@ -75,31 +75,26 @@ class SegmentationModel(AgMLModelBase):
     parameter `net`, and you'll need to implement methods like `training_step`,
     `configure_optimizers`, etc. See PyTorch Lightning for more information.
     """
-    serializable = frozenset((
-        "net", "num_classes", "conf_thresh", "image_size"))
+
+    serializable = frozenset(("net", "num_classes", "conf_thresh", "image_size"))
     state_override = frozenset(("net",))
 
-    _ml_task = 'semantic_segmentation'
+    _ml_task = "semantic_segmentation"
 
-    def __init__(self,
-                 num_classes = 1,
-                 image_size = 512,
-                 **kwargs):
+    def __init__(self, num_classes=1, image_size=512, **kwargs):
         # Construct the network and load in pretrained weights.
         super(SegmentationModel, self).__init__()
 
         # If being initialized by a subclass, then don't do any of
         # model construction logic (since that's already been done).
-        if not kwargs.get('model_initialized', False):
+        if not kwargs.get("model_initialized", False):
             self._num_classes = num_classes
             self._image_size = resolve_image_size(image_size)
             self.net = self._construct_sub_net(num_classes)
             if self._num_classes == 1:
-                conf_threshold = kwargs.get('conf_threshold', 0.2)
+                conf_threshold = kwargs.get("conf_threshold", 0.2)
                 if not 0 < conf_threshold < 1:
-                    raise ValueError(
-                        "The given confidence threshold "
-                        "must be between 0 and 1.")
+                    raise ValueError("The given confidence threshold " "must be between 0 and 1.")
                 self._conf_thresh = conf_threshold
 
         # By default, the model starts in inference mode.
@@ -131,9 +126,9 @@ def _preprocess_image(image, image_size, **kwargs):
         as well as other intermediate steps such as adding a channel
         dimension for two-channel inputs, for example.
         """
-        return imagenet_style_process(image, size = image_size, **kwargs)
+        return imagenet_style_process(image, size=image_size, **kwargs)
 
-    def preprocess_input(self, images, return_shapes = False, **kwargs):
+    def preprocess_input(self, images, return_shapes=False, **kwargs):
         """Preprocesses the input image to the specification of the model.
 
         This method takes in a set of inputs and preprocesses them into the
@@ -175,8 +170,9 @@ def preprocess_input(self, images, return_shapes = False, **kwargs):
         images = self._expand_input_images(images)
         shapes = self._get_shapes(images)
         images = torch.stack(
-            [self._preprocess_image(
-                image, self._image_size, **kwargs) for image in images], dim = 0)
+            [self._preprocess_image(image, self._image_size, **kwargs) for image in images],
+            dim=0,
+        )
         if return_shapes:
             return images, shapes
         return images
@@ -208,27 +204,33 @@ def predict(self, images, **kwargs):
         A list of `np.ndarray`s with resized output masks.
         """
         # Process the images and run inference.
-        images, shapes = self.preprocess_input(images, return_shapes = True, **kwargs)
+        images, shapes = self.preprocess_input(images, return_shapes=True, **kwargs)
         out = torch.sigmoid(self.forward(images))
 
         # Post-process the output masks to a valid format.
         if out.shape[1] == 1:  # binary class predictions
             out[out >= self._conf_thresh] = 1
             out[out != 1] = 0
-            out = torch.squeeze(out, dim = 1)
-        else: # multi-class predictions to integer labels
+            out = torch.squeeze(out, dim=1)
+        else:  # multi-class predictions to integer labels
             out = torch.argmax(out, 1)
 
         # Resize the masks to their original shapes.
         masks = []
-        for mask, shape in zip(
-                torch.index_select(out, 0, torch.arange(len(out))), shapes):
-            masks.append(self._to_out(torch.squeeze(F.interpolate(
-                torch.unsqueeze(torch.unsqueeze(mask, 0), 0).float(),
-                size = shape).int())))
+        for mask, shape in zip(torch.index_select(out, 0, torch.arange(len(out))), shapes):
+            masks.append(
+                self._to_out(
+                    torch.squeeze(
+                        F.interpolate(
+                            torch.unsqueeze(torch.unsqueeze(mask, 0), 0).float(),
+                            size=shape,
+                        ).int()
+                    )
+                )
+            )
         return resolve_list_value(masks)
 
-    def show_prediction(self, image, overlay = False, **kwargs):
+    def show_prediction(self, image, overlay=False, **kwargs):
         """Shows the output predictions for one input image.
 
         This method is useful for instantly visualizing the predictions
@@ -276,18 +278,20 @@ def load_benchmark(self, dataset):
         If the benchmark has a different number of classes than this input model, then
         this method will raise an error. This issue may be adapted in the future.
         """
-        if source(dataset).tasks.ml != 'semantic_segmentation':
+        if source(dataset).tasks.ml != "semantic_segmentation":
             raise ValueError(
                 f"You are trying to load a benchmark for a "
                 f"{source(dataset).tasks.ml} task ({dataset}) "
-                f"in a semantic segmentation model.")
+                f"in a semantic segmentation model."
+            )
 
         # Number of classes must be the same for semantic segmentation.
         if source(dataset).num_classes != self._num_classes:
             raise ValueError(
                 f"You cannot load a benchmark for a dataset '{dataset}' "
                 f"with {source(dataset).num_classes} classes, while your "
-                f"model has {self._num_classes} classes.")
+                f"model has {self._num_classes} classes."
+            )
 
         # Load the benchmark.
         state = self._get_benchmark(dataset)
@@ -310,39 +314,43 @@ def evaluate(self, loader, **kwargs):
         The final calculated mIoU.
         """
         # Construct the metric and run the calculations.
-        iou = IoU(num_classes = self._num_classes + 1, task="binary")
-        bar = tqdm(loader, desc = "Calculating Mean Intersection Over Union")
+        iou = IoU(num_classes=self._num_classes + 1, task="binary")
+        bar = tqdm(loader, desc="Calculating Mean Intersection Over Union")
         for sample in bar:
             image, truth = sample
             pred_mask = self.predict(image, **kwargs)
             if pred_mask.ndim == 3:
                 pred_mask = np.transpose(pred_mask, (2, 0, 1))
                 truth = np.transpose(truth, (2, 0, 1))
-            iou(torch.from_numpy(pred_mask).int().unsqueeze(0),
-                torch.from_numpy(truth).unsqueeze(0))
-            bar.set_postfix({'miou': iou.compute().numpy().item()})
+            iou(
+                torch.from_numpy(pred_mask).int().unsqueeze(0),
+                torch.from_numpy(truth).unsqueeze(0),
+            )
+            bar.set_postfix({"miou": iou.compute().numpy().item()})
 
         # Compute the final mIoU.
         return iou.compute().numpy().item()
 
-    def run_training(self,
-                     dataset=None,
-                     *,
-                     epochs=50,
-                     loss=None,
-                     metrics=None,
-                     optimizer=None,
-                     lr_scheduler=None,
-                     lr=None,
-                     batch_size=8,
-                     loggers=None,
-                     train_dataloader=None,
-                     val_dataloader=None,
-                     test_dataloader=None,
-                     use_cpu=False,
-                     save_dir=None,
-                     experiment_name=None,
-                     **kwargs):
+    def run_training(
+        self,
+        dataset=None,
+        *,
+        epochs=50,
+        loss=None,
+        metrics=None,
+        optimizer=None,
+        lr_scheduler=None,
+        lr=None,
+        batch_size=8,
+        loggers=None,
+        train_dataloader=None,
+        val_dataloader=None,
+        test_dataloader=None,
+        use_cpu=False,
+        save_dir=None,
+        experiment_name=None,
+        **kwargs,
+    ):
         """Trains a semantic segmentation model.
 
         This method can be used to train a semantic segmentation model on a given
@@ -432,46 +440,41 @@ def run_training(self,
 
         return train_segmentation(
             self,
-            dataset = dataset,
-            epochs = epochs,
-            loss = loss,
-            metrics = metrics,
-            optimizer = optimizer,
-            lr_scheduler = lr_scheduler,
-            lr = lr,
+            dataset=dataset,
+            epochs=epochs,
+            loss=loss,
+            metrics=metrics,
+            optimizer=optimizer,
+            lr_scheduler=lr_scheduler,
+            lr=lr,
             batch_size=batch_size,
-            loggers = loggers,
-            train_dataloader = train_dataloader,
-            val_dataloader = val_dataloader,
-            test_dataloader = test_dataloader,
-            use_cpu = use_cpu,
-            save_dir = save_dir,
-            experiment_name = experiment_name,
-            **kwargs
+            loggers=loggers,
+            train_dataloader=train_dataloader,
+            val_dataloader=val_dataloader,
+            test_dataloader=test_dataloader,
+            use_cpu=use_cpu,
+            save_dir=save_dir,
+            experiment_name=experiment_name,
+            **kwargs,
         )
 
-    def _prepare_for_training(self,
-                              loss = 'ce',
-                              metrics = (),
-                              optimizer = None,
-                              **kwargs):
+    def _prepare_for_training(self, loss="ce", metrics=(), optimizer=None, **kwargs):
         """Prepares the model for training."""
 
         # Initialize the loss
-        if loss == 'ce':
+        if loss == "ce":
             # either binary or multiclass, binary is likely never used
             if self._num_classes == 1:
                 self.loss = nn.BCEWithLogitsLoss()
             else:
                 self.loss = nn.CrossEntropyLoss()
-        elif loss == 'dice':
+        elif loss == "dice":
             if self._num_classes == 1:
                 log("Dice loss is not necessarily supported for binary classification.")
             self.loss = DiceLoss()
         else:
             if not isinstance(loss, nn.Module) or not callable(loss):
-                raise TypeError(
-                    f"Expected a callable loss function, but got '{type(loss)}'.")
+                raise TypeError(f"Expected a callable loss function, but got '{type(loss)}'.")
 
         # Initialize the metrics.
         metric_collection = []
@@ -485,26 +488,33 @@ def _prepare_for_training(self,
                         raise ImportError(
                             "Received the name of a metric. If you want to use named "
                             "metrics, then you need to have `torchmetrics` installed. "
-                            "You can do this by running `pip install torchmetrics`.")
+                            "You can do this by running `pip install torchmetrics`."
+                        )
 
                     # Check if `torchmetrics.classification` has the metric.
                     if has_func(class_metrics, metric):
                         # iou/miou is a special case
-                        if metric == 'iou' or metric == 'miou':
+                        if metric == "iou" or metric == "miou":
                             metric_collection.append(
-                                [metric, IoU(
-                                    task = 'multiclass' if self._num_classes > 1 else 'binary',  # noqa
-                                    num_classes = self._num_classes + 1)])
+                                [
+                                    metric,
+                                    IoU(
+                                        task="multiclass" if self._num_classes > 1 else "binary",  # noqa
+                                        num_classes=self._num_classes + 1,
+                                    ),
+                                ]
+                            )
 
                         # convert to camel case
                         else:
-                            metric = ''.join([word.capitalize() for word in metric.split('_')])
+                            metric = "".join([word.capitalize() for word in metric.split("_")])
                             metric_collection.append([metric, getattr(class_metrics, metric)()])
                     else:
                         raise ValueError(
                             f"Expected a valid metric torchmetrics metric name, "
                             f"but got '{metric}'. Check `torchmetrics.classification` "
-                            f"for a list of valid image classification metrics.")
+                            f"for a list of valid image classification metrics."
+                        )
 
                 # Check if it is any other class.
                 elif isinstance(metric, nn.Module):
@@ -512,8 +522,7 @@ def _prepare_for_training(self,
 
                 # Otherwise, raise an error.
                 else:
-                    raise TypeError(
-                        f"Expected a metric name or a metric class, but got '{type(metric)}'.")
+                    raise TypeError(f"Expected a metric name or a metric class, but got '{type(metric)}'.")
         self._metrics = metric_collection
 
         # Initialize the optimizer/learning rate scheduler.
@@ -522,40 +531,39 @@ def _prepare_for_training(self,
             if not has_func(torch.optim, optimizer_class):
                 raise ValueError(
                     f"Expected a valid optimizer name, but got '{optimizer_class}'. "
-                    f"Check `torch.optim` for a list of valid optimizers.")
+                    f"Check `torch.optim` for a list of valid optimizers."
+                )
 
-            optimizer = getattr(torch.optim, optimizer_class)(
-                self.parameters(), lr = kwargs.get('lr', 2e-3))
+            optimizer = getattr(torch.optim, optimizer_class)(self.parameters(), lr=kwargs.get("lr", 2e-3))
         elif isinstance(optimizer, torch.optim.Optimizer):
             pass  # nothing to do
         else:
-            raise TypeError(
-                f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
+            raise TypeError(f"Expected an optimizer name or a torch optimizer, but got '{type(optimizer)}'.")
 
-        scheduler = kwargs.get('lr_scheduler', None)
+        scheduler = kwargs.get("lr_scheduler", None)
         if scheduler is not None:
             # No string auto-initialization, the LR scheduler must be pre-configured.
             if isinstance(scheduler, str):
                 raise ValueError(
                     f"If you want to use a learning rate scheduler, you must initialize "
-                    f"it on your own and pass it to the `lr_scheduler` argument. ")
+                    f"it on your own and pass it to the `lr_scheduler` argument. "
+                )
             elif not isinstance(scheduler, torch.optim.lr_scheduler.LRScheduler):
-                raise TypeError(
-                    f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
+                raise TypeError(f"Expected a torch LR scheduler, but got '{type(scheduler)}'.")
 
         self._optimization_parameters = {
-            'optimizer': optimizer,
-            'lr_scheduler': scheduler
+            "optimizer": optimizer,
+            "lr_scheduler": scheduler,
         }
 
     def configure_optimizers(self):
-        opt = self._optimization_parameters['optimizer']
-        scheduler = self._optimization_parameters['lr_scheduler']
+        opt = self._optimization_parameters["optimizer"]
+        scheduler = self._optimization_parameters["lr_scheduler"]
         if scheduler is None:
             return opt
         return [opt], [scheduler]
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y = y.float()
         y_pred = self(x).float().squeeze()
@@ -564,27 +572,31 @@ def training_step(self, batch, *args, **kwargs): # noqa
         loss = self.loss(y_pred, y)
         for metric_name, metric in self._metrics:
             metric.update(y_pred, y)
-            self.log(metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(metric_name, self._to_out(metric.compute()).item(), prog_bar=True)
 
         return {
-            'loss': loss,
+            "loss": loss,
         }
 
-    def validation_step(self, batch, *args, **kwargs): # noqa
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y = y.float()
         y_pred = self(x).float().squeeze()
 
         # Compute metrics and loss.
         val_loss = self.loss(y_pred, y)
-        self.log('val_loss', val_loss.item(), prog_bar = True)
+        self.log("val_loss", val_loss.item(), prog_bar=True)
         for metric_name, metric in self._metrics:
             metric.to(self.device)
             metric.update(y_pred, y)
-            self.log('val_' + metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(
+                "val_" + metric_name,
+                self._to_out(metric.compute()).item(),
+                prog_bar=True,
+            )
 
         return {
-            'val_loss': val_loss,
+            "val_loss": val_loss,
         }
 
     def test_step(self, batch, *args, **kwargs):
@@ -594,14 +606,16 @@ def test_step(self, batch, *args, **kwargs):
 
         # Compute metrics and loss.
         test_loss = self.loss(y_pred, y)
-        self.log('test_loss', test_loss.item(), prog_bar = True)
+        self.log("test_loss", test_loss.item(), prog_bar=True)
         for metric_name, metric in self._metrics:
             metric.update(y_pred, y)
 
-            self.log('test_' + metric_name, self._to_out(metric.compute()).item(), prog_bar = True)
+            self.log(
+                "test_" + metric_name,
+                self._to_out(metric.compute()).item(),
+                prog_bar=True,
+            )
 
         return {
-            'test_loss': test_loss,
+            "test_loss": test_loss,
         }
-
-
diff --git a/agml/models/system_utils.py b/agml/models/system_utils.py
index 8476bfa0..c8a48cbe 100644
--- a/agml/models/system_utils.py
+++ b/agml/models/system_utils.py
@@ -19,9 +19,8 @@ def get_accelerator(use_cpu=False):
     """Returns the accelerator device to use for training."""
     if not use_cpu:
         if torch.cuda.is_available():
-            return 'cuda'
+            return "cuda"
         if torch.has_mps:
-            return 'mps'
+            return "mps"
     else:
-        return 'cpu'
-
+        return "cpu"
diff --git a/agml/models/tools.py b/agml/models/tools.py
index c729501e..8545573c 100644
--- a/agml/models/tools.py
+++ b/agml/models/tools.py
@@ -12,17 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable
 from functools import wraps
+from typing import Callable
 
-import torch
-import numpy as np
 import albumentations as A
+import numpy as np
+import torch
 
 from agml.backend.tftorch import is_array_like
 
 
-def imagenet_style_process(image, size = None, **kwargs):
+def imagenet_style_process(image, size=None, **kwargs):
     """Preprocesses a single input image to ImageNet standards.
 
     The preprocessing steps are applied logically; if the images
@@ -40,12 +40,12 @@ def imagenet_style_process(image, size = None, **kwargs):
     dimension for two-channel inputs, for example.
     """
     # Convert the image to a NumPy array.
-    if is_array_like(image) and hasattr(image, 'numpy'):
+    if is_array_like(image) and hasattr(image, "numpy"):
         image = image.numpy()
 
     # Add a channel dimension for grayscale imagery.
     if image.ndim == 2:
-        image = np.expand_dims(image, axis = -1)
+        image = np.expand_dims(image, axis=-1)
 
     # If the image is already in channels-first format, convert
     # it back temporarily until preprocessing has concluded.
@@ -56,21 +56,21 @@ def imagenet_style_process(image, size = None, **kwargs):
     h = w = 224
     if size is not None:
         h, w = size
-    rz = A.Resize(height = h, width = w)
+    rz = A.Resize(height=h, width=w)
     if image.shape[0] != h or image.shape[1] != w:
-        image = rz(image = image)['image']
+        image = rz(image=image)["image"]
 
     # Normalize the image to ImageNet standards.
-    if kwargs.get('normalize', True):
+    if kwargs.get("normalize", True):
         if 1 <= image.max() <= 255:
             mean = [0.485, 0.456, 0.406]
             std = [0.229, 0.224, 0.225]
-            image = image.astype(np.float32) / 255.
-            mean = np.array(mean, dtype = np.float32)
-            std = np.array(std, dtype = np.float32)
-            denominator = np.reciprocal(std, dtype = np.float32)
+            image = image.astype(np.float32) / 255.0
+            mean = np.array(mean, dtype=np.float32)
+            std = np.array(std, dtype=np.float32)
+            denominator = np.reciprocal(std, dtype=np.float32)
             image = (image - mean) * denominator
-    else: # Otherwise, just scale the image.
+    else:  # Otherwise, just scale the image.
         if 1 <= image.max() <= 255:
             image = image.astype(np.float32) / 255.0
 
@@ -122,10 +122,7 @@ def auto_transfer_args(self, *args, **kwargs):
         if not isinstance(self, LightningModule):
             return fn(self, *args, **kwargs)
 
-        args, kwargs = self.transfer_batch_to_device(
-            (args, kwargs), device = self.device, dataloader_idx = None) # noqa
+        args, kwargs = self.transfer_batch_to_device((args, kwargs), device=self.device, dataloader_idx=None)  # noqa
         return fn(self, *args, **kwargs)
 
     return auto_transfer_args
-
-
diff --git a/agml/models/training/basic_trainers.py b/agml/models/training/basic_trainers.py
index 8a82bdc3..a6759ff1 100644
--- a/agml/models/training/basic_trainers.py
+++ b/agml/models/training/basic_trainers.py
@@ -12,12 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import datetime
+import os
 
 import torch
 from pytorch_lightning import Trainer
 from pytorch_lightning.loggers import TensorBoardLogger
+
 try:  # newer pytorch versions
     from pytorch_lightning.loggers import Logger
 except ImportError:
@@ -25,30 +26,32 @@
 from pytorch_lightning.callbacks import ModelCheckpoint
 
 from agml.models.classification import ClassificationModel
-from agml.models.segmentation import SegmentationModel
 from agml.models.detection import DetectionModel
+from agml.models.segmentation import SegmentationModel
 from agml.models.system_utils import get_accelerator
 from agml.utils.logging import log
 
 
-def train_classification(model,
-                         *,
-                         dataset=None,
-                         epochs=50,
-                         loss=None,
-                         metrics=None,
-                         optimizer=None,
-                         lr_scheduler=None,
-                         lr=None,
-                         batch_size=8,
-                         loggers=None,
-                         train_dataloader=None,
-                         val_dataloader=None,
-                         test_dataloader=None,
-                         use_cpu=False,
-                         save_dir=None,
-                         experiment_name=None,
-                         **kwargs):
+def train_classification(
+    model,
+    *,
+    dataset=None,
+    epochs=50,
+    loss=None,
+    metrics=None,
+    optimizer=None,
+    lr_scheduler=None,
+    lr=None,
+    batch_size=8,
+    loggers=None,
+    train_dataloader=None,
+    val_dataloader=None,
+    test_dataloader=None,
+    use_cpu=False,
+    save_dir=None,
+    experiment_name=None,
+    **kwargs,
+):
     """Trains an image classification model.
 
     This method can be used to train an image classification model on a given
@@ -138,66 +141,59 @@ def train_classification(model,
     # (1) The input dataset is a valid image classification dataset
     # (2) The input dataset has split data
     # (3) Only one of `dataset` and the `dataloader`s has been passed.
-    if not dataset.info.tasks.ml == 'image_classification':
+    if not dataset.info.tasks.ml == "image_classification":
         raise ValueError("The dataset must be an image classification dataset.")
-    dataset_exists, dataloader_exists = \
-        dataset is not None, any([train_dataloader, val_dataloader, test_dataloader])
+    dataset_exists, dataloader_exists = (
+        dataset is not None,
+        any([train_dataloader, val_dataloader, test_dataloader]),
+    )
     if not (dataset_exists ^ dataloader_exists):
         raise ValueError("You must pass one and only one of the dataset/dataloader arguments.")
 
     if dataset_exists:
-        nw = kwargs.get('num_workers', None)
+        nw = kwargs.get("num_workers", None)
         if nw is None:
             nw = os.cpu_count() // 2
         if not any([dataset.train_data, dataset.val_data, dataset.test_data]):
             raise ValueError("The provided dataset must have split data.")
         if dataset.train_data is not None:
-            train_dataloader = dataset.train_data.export_torch(
-                batch_size = batch_size,
-                shuffle = True,
-                num_workers = nw
-            )
+            train_dataloader = dataset.train_data.export_torch(batch_size=batch_size, shuffle=True, num_workers=nw)
         if dataset.val_data is not None:
-            val_dataloader = dataset.val_data.export_torch(
-                batch_size = batch_size,
-                shuffle = False,
-                num_workers = nw
-            )
+            val_dataloader = dataset.val_data.export_torch(batch_size=batch_size, shuffle=False, num_workers=nw)
         if dataset.test_data is not None:
-            test_dataloader = dataset.test_data.export_torch(
-                batch_size = batch_size,
-                shuffle = False,
-                num_workers = nw
-            )
+            test_dataloader = dataset.test_data.export_torch(batch_size=batch_size, shuffle=False, num_workers=nw)
         dataset_name = dataset.info.name
 
     # Set up the model for training (and choose the default parameters).
     if not isinstance(model, ClassificationModel):
-        raise ValueError("Expected an `agml.models.ClassificationModel` for an image "
-                         "classification task, instead got {}.".format(type(model)))
+        raise ValueError(
+            "Expected an `agml.models.ClassificationModel` for an image " "classification task, instead got {}.".format(
+                type(model)
+            )
+        )
 
     if loss is None:
-        loss = 'ce'
+        loss = "ce"
     if optimizer is None:
-        optimizer = 'adam'
+        optimizer = "adam"
     if metrics is None:
-        metrics = ['accuracy']
+        metrics = ["accuracy"]
     elif isinstance(metrics, str):
         metrics = [metrics]
     if lr is None:
-        if kwargs.get('learning_rate', None) is not None:
-            lr = kwargs['learning_rate']
+        if kwargs.get("learning_rate", None) is not None:
+            lr = kwargs["learning_rate"]
         else:
             lr = 1e-3
-    elif lr is not None and kwargs.get('learning_rate', None) is not None:
+    elif lr is not None and kwargs.get("learning_rate", None) is not None:
         raise ValueError("You cannot pass both `lr` and `learning_rate`.")
 
     model._prepare_for_training(
-        loss = loss,
-        metrics = metrics,
-        optimizer = optimizer,
-        lr_scheduler = lr_scheduler,
-        lr = lr,
+        loss=loss,
+        metrics=metrics,
+        optimizer=optimizer,
+        lr_scheduler=lr_scheduler,
+        lr=lr,
     )
 
     # Set up the trainer.
@@ -206,57 +202,59 @@ def train_classification(model,
             os.makedirs(save_dir, exist_ok=True)
             log("Created directory ({}) for saving training logs.".format(save_dir))
     else:
-        save_dir = os.path.join(os.getcwd(), 'agml_training_logs')
+        save_dir = os.path.join(os.getcwd(), "agml_training_logs")
         if not os.path.exists(save_dir):
             os.makedirs(save_dir, exist_ok=True)
             log("Created directory ({}) for saving training logs.".format(save_dir))
     if experiment_name is None:
         curr_datetime = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M")
         if dataset_exists:
-            experiment_name = '{}_{}_{}'.format(
-                'image_classification', dataset_name, curr_datetime)  # noqa
+            experiment_name = "{}_{}_{}".format("image_classification", dataset_name, curr_datetime)  # noqa
         else:
-            experiment_name = '{}_{}_{}'.format(
-                'image_classification', 'unknown', curr_datetime)
+            experiment_name = "{}_{}_{}".format("image_classification", "unknown", curr_datetime)
     if loggers is not None:
         for _logger in loggers:
             if not isinstance(_logger, Logger):
-                raise ValueError("Expected a `pytorch_lightning.loggers.Logger` for a "
-                                 "logger, instead got {}.".format(type(_logger)))
+                raise ValueError(
+                    "Expected a `pytorch_lightning.loggers.Logger` for a " "logger, instead got {}.".format(
+                        type(_logger)
+                    )
+                )
     else:
-        loggers = [TensorBoardLogger(save_dir, name = experiment_name)]
+        loggers = [TensorBoardLogger(save_dir, name=experiment_name)]
     save_dir = os.path.join(save_dir, experiment_name)
-    checkpoint_callback = ModelCheckpoint(save_dir, monitor='val_loss', mode='min', save_top_k=1)
+    checkpoint_callback = ModelCheckpoint(save_dir, monitor="val_loss", mode="min", save_top_k=1)
 
-    accelerator = get_accelerator(use_cpu = use_cpu)
-    if accelerator == 'cuda':
+    accelerator = get_accelerator(use_cpu=use_cpu)
+    if accelerator == "cuda":
         try:  # newer pytorch versions
             from pytorch_lightning.accelerators import find_usable_cuda_devices
+
             devices = find_usable_cuda_devices()
         except ImportError:
-            accelerator = 'gpu'
-            devices = 'auto'
+            accelerator = "gpu"
+            devices = "auto"
     else:
-        devices = 'auto'
+        devices = "auto"
 
     trainer = Trainer(
-        max_epochs = epochs,
-        accelerator = accelerator,
-        devices = devices,
-        logger = loggers,
-        callbacks = [checkpoint_callback],
-        log_every_n_steps = 2,
+        max_epochs=epochs,
+        accelerator=accelerator,
+        devices=devices,
+        logger=loggers,
+        callbacks=[checkpoint_callback],
+        log_every_n_steps=2,
     )
 
     # Train and test the model.
     trainer.fit(
         model,
-        train_dataloaders = train_dataloader,
-        val_dataloaders = val_dataloader,
+        train_dataloaders=train_dataloader,
+        val_dataloaders=val_dataloader,
     )
 
     if test_dataloader is not None:
-        trainer.test(dataloaders = test_dataloader)
+        trainer.test(dataloaders=test_dataloader)
 
     # Get the saved path for the best model.
     best_model_path = checkpoint_callback.best_model_path
@@ -265,24 +263,26 @@ def train_classification(model,
     return model
 
 
-def train_segmentation(model,
-                       *,
-                       dataset=None,
-                       epochs=50,
-                       loss=None,
-                       metrics=None,
-                       optimizer=None,
-                       lr_scheduler=None,
-                       lr=None,
-                       batch_size=8,
-                       loggers=None,
-                       train_dataloader=None,
-                       val_dataloader=None,
-                       test_dataloader=None,
-                       use_cpu=False,
-                       save_dir=None,
-                       experiment_name=None,
-                       **kwargs):
+def train_segmentation(
+    model,
+    *,
+    dataset=None,
+    epochs=50,
+    loss=None,
+    metrics=None,
+    optimizer=None,
+    lr_scheduler=None,
+    lr=None,
+    batch_size=8,
+    loggers=None,
+    train_dataloader=None,
+    val_dataloader=None,
+    test_dataloader=None,
+    use_cpu=False,
+    save_dir=None,
+    experiment_name=None,
+    **kwargs,
+):
     """Trains a semantic segmentation model.
 
     This method can be used to train a semantic segmentation model on a given
@@ -372,69 +372,62 @@ def train_segmentation(model,
     # (1) The input dataset is a valid semantic segmentation dataset
     # (2) The input dataset has split data
     # (3) Only one of `dataset` and the `dataloader`s has been passed.
-    if not dataset.info.tasks.ml == 'semantic_segmentation':
+    if not dataset.info.tasks.ml == "semantic_segmentation":
         raise ValueError("The dataset must be a semantic segmentation dataset.")
-    dataset_exists, dataloader_exists = \
-        dataset is not None, any([train_dataloader, val_dataloader, test_dataloader])
+    dataset_exists, dataloader_exists = (
+        dataset is not None,
+        any([train_dataloader, val_dataloader, test_dataloader]),
+    )
     if not (dataset_exists ^ dataloader_exists):
         raise ValueError("You must pass one and only one of the dataset/dataloader arguments.")
 
     if dataset_exists:
-        nw = kwargs.get('num_workers', None)
+        nw = kwargs.get("num_workers", None)
         if nw is None:
             nw = os.cpu_count() // 2
         if not any([dataset.train_data, dataset.val_data, dataset.test_data]):
             raise ValueError("The provided dataset must have split data.")
         if dataset.train_data is not None:
-            train_dataloader = dataset.train_data.export_torch(
-                batch_size = batch_size,
-                shuffle = True,
-                num_workers = nw
-            )
+            train_dataloader = dataset.train_data.export_torch(batch_size=batch_size, shuffle=True, num_workers=nw)
         if dataset.val_data is not None:
-            val_dataloader = dataset.val_data.export_torch(
-                batch_size = batch_size,
-                shuffle = False,
-                num_workers = nw
-            )
+            val_dataloader = dataset.val_data.export_torch(batch_size=batch_size, shuffle=False, num_workers=nw)
         if dataset.test_data is not None:
-            test_dataloader = dataset.test_data.export_torch(
-                batch_size = batch_size,
-                shuffle = False,
-                num_workers = nw
-            )
+            test_dataloader = dataset.test_data.export_torch(batch_size=batch_size, shuffle=False, num_workers=nw)
         dataset_name = dataset.info.name
 
     # Set up the model for training (and choose the default parameters).
     if not isinstance(model, SegmentationModel):
-        raise ValueError("Expected an `agml.models.SegmentationModel` for an image "
-                         "classification task, instead got {}.".format(type(model)))
+        raise ValueError(
+            "Expected an `agml.models.SegmentationModel` for an image " "classification task, instead got {}.".format(
+                type(model)
+            )
+        )
 
     if loss is None:
         if dataset.num_classes > 1:
-            loss = 'dice'
+            loss = "dice"
         else:
-            loss = 'ce'
+            loss = "ce"
     if metrics is None:
-        metrics = ['miou']
+        metrics = ["miou"]
     elif isinstance(metrics, str):
         metrics = [metrics]
     if lr is None:
-        if kwargs.get('learning_rate', None) is not None:
-            lr = kwargs['learning_rate']
+        if kwargs.get("learning_rate", None) is not None:
+            lr = kwargs["learning_rate"]
         else:
             lr = 5e-3
     if optimizer is None:
-        optimizer = torch.optim.NAdam(model.parameters(), lr = lr)
-    elif lr is not None and kwargs.get('learning_rate', None) is not None:
+        optimizer = torch.optim.NAdam(model.parameters(), lr=lr)
+    elif lr is not None and kwargs.get("learning_rate", None) is not None:
         raise ValueError("You cannot pass both `lr` and `learning_rate`.")
 
     model._prepare_for_training(
-        loss = loss,
-        metrics = metrics,
-        optimizer = optimizer,
-        lr_scheduler = lr_scheduler,
-        lr = lr,
+        loss=loss,
+        metrics=metrics,
+        optimizer=optimizer,
+        lr_scheduler=lr_scheduler,
+        lr=lr,
     )
 
     # Set up the trainer.
@@ -443,57 +436,59 @@ def train_segmentation(model,
             os.makedirs(save_dir, exist_ok=True)
             log("Created directory ({}) for saving training logs.".format(save_dir))
     else:
-        save_dir = os.path.join(os.getcwd(), 'agml_training_logs')
+        save_dir = os.path.join(os.getcwd(), "agml_training_logs")
         if not os.path.exists(save_dir):
             os.makedirs(save_dir, exist_ok=True)
             log("Created directory ({}) for saving training logs.".format(save_dir))
     if experiment_name is None:
         curr_datetime = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M")
         if dataset_exists:
-            experiment_name = '{}_{}_{}'.format(
-                'semantic_segmentation', dataset_name, curr_datetime)  # noqa
+            experiment_name = "{}_{}_{}".format("semantic_segmentation", dataset_name, curr_datetime)  # noqa
         else:
-            experiment_name = '{}_{}_{}'.format(
-                'semantic_segmentation', 'unknown', curr_datetime)
+            experiment_name = "{}_{}_{}".format("semantic_segmentation", "unknown", curr_datetime)
     save_dir = os.path.join(save_dir, experiment_name)
     if loggers is not None:
         for _logger in loggers:
             if not isinstance(_logger, Logger):
-                raise ValueError("Expected a `pytorch_lightning.loggers.Logger` for a "
-                                 "logger, instead got {}.".format(type(_logger)))
+                raise ValueError(
+                    "Expected a `pytorch_lightning.loggers.Logger` for a " "logger, instead got {}.".format(
+                        type(_logger)
+                    )
+                )
     else:
-        loggers = [TensorBoardLogger(save_dir, name = experiment_name)]
-    checkpoint_callback = ModelCheckpoint(save_dir, monitor='val_loss', mode='min', save_top_k=1)
+        loggers = [TensorBoardLogger(save_dir, name=experiment_name)]
+    checkpoint_callback = ModelCheckpoint(save_dir, monitor="val_loss", mode="min", save_top_k=1)
 
-    accelerator = get_accelerator(use_cpu = use_cpu)
-    if accelerator == 'cuda':
+    accelerator = get_accelerator(use_cpu=use_cpu)
+    if accelerator == "cuda":
         try:  # newer pytorch versions
             from pytorch_lightning.accelerators import find_usable_cuda_devices
+
             devices = find_usable_cuda_devices()
         except ImportError:
-            accelerator = 'gpu'
-            devices = 'auto'
+            accelerator = "gpu"
+            devices = "auto"
     else:
-        devices = 'auto'
+        devices = "auto"
 
     trainer = Trainer(
-        max_epochs = epochs,
-        accelerator = accelerator,
-        devices = devices,
-        logger = loggers,
-        callbacks = [checkpoint_callback],
-        log_every_n_steps = 2,
+        max_epochs=epochs,
+        accelerator=accelerator,
+        devices=devices,
+        logger=loggers,
+        callbacks=[checkpoint_callback],
+        log_every_n_steps=2,
     )
 
     # Train and test the model.
     trainer.fit(
         model,
-        train_dataloaders = train_dataloader,
-        val_dataloaders = val_dataloader,
+        train_dataloaders=train_dataloader,
+        val_dataloaders=val_dataloader,
     )
 
     if test_dataloader is not None:
-        trainer.test(dataloaders = test_dataloader)
+        trainer.test(dataloaders=test_dataloader)
 
     # Get the saved path for the best model.
     best_model_path = checkpoint_callback.best_model_path
@@ -502,23 +497,25 @@ def train_segmentation(model,
     return model
 
 
-def train_detection(model,
-                    *,
-                    dataset=None,
-                    epochs=50,
-                    metrics=None,
-                    optimizer=None,
-                    lr_scheduler=None,
-                    lr=None,
-                    batch_size=8,
-                    loggers=None,
-                    train_dataloader=None,
-                    val_dataloader=None,
-                    test_dataloader=None,
-                    use_cpu=False,
-                    save_dir=None,
-                    experiment_name=None,
-                    **kwargs):
+def train_detection(
+    model,
+    *,
+    dataset=None,
+    epochs=50,
+    metrics=None,
+    optimizer=None,
+    lr_scheduler=None,
+    lr=None,
+    batch_size=8,
+    loggers=None,
+    train_dataloader=None,
+    val_dataloader=None,
+    test_dataloader=None,
+    use_cpu=False,
+    save_dir=None,
+    experiment_name=None,
+    **kwargs,
+):
     """Trains an object detection model.
 
     This method can be used to train an object detection model on a given
@@ -606,63 +603,56 @@ def train_detection(model,
     # (1) The input dataset is a valid object detection dataset
     # (2) The input dataset has split data
     # (3) Only one of `dataset` and the `dataloader`s has been passed.
-    if not dataset.info.tasks.ml == 'object_detection':
+    if not dataset.info.tasks.ml == "object_detection":
         raise ValueError("The dataset must be a object detection dataset.")
-    dataset_exists, dataloader_exists = \
-        dataset is not None, any([train_dataloader, val_dataloader, test_dataloader])
+    dataset_exists, dataloader_exists = (
+        dataset is not None,
+        any([train_dataloader, val_dataloader, test_dataloader]),
+    )
     if not (dataset_exists ^ dataloader_exists):
         raise ValueError("You must pass one and only one of the dataset/dataloader arguments.")
 
     if dataset_exists:
-        nw = kwargs.get('num_workers', None)
+        nw = kwargs.get("num_workers", None)
         if nw is None:
             nw = os.cpu_count() // 2
         if not any([dataset.train_data, dataset.val_data, dataset.test_data]):
             raise ValueError("The provided dataset must have split data.")
         if dataset.train_data is not None:
-            train_dataloader = dataset.train_data.export_torch(
-                batch_size = batch_size,
-                shuffle = True,
-                num_workers = nw
-            )
+            train_dataloader = dataset.train_data.export_torch(batch_size=batch_size, shuffle=True, num_workers=nw)
         if dataset.val_data is not None:
-            val_dataloader = dataset.val_data.export_torch(
-                batch_size = batch_size,
-                shuffle = False,
-                num_workers = nw
-            )
+            val_dataloader = dataset.val_data.export_torch(batch_size=batch_size, shuffle=False, num_workers=nw)
         if dataset.test_data is not None:
-            test_dataloader = dataset.test_data.export_torch(
-                batch_size = batch_size,
-                shuffle = False,
-                num_workers = nw
-            )
+            test_dataloader = dataset.test_data.export_torch(batch_size=batch_size, shuffle=False, num_workers=nw)
         dataset_name = dataset.info.name
 
     # Set up the model for training (and choose the default parameters).
     if not isinstance(model, DetectionModel):
-        raise ValueError("Expected an `agml.models.DetectionModel` for an image "
-                         "classification task, instead got {}.".format(type(model)))
+        raise ValueError(
+            "Expected an `agml.models.DetectionModel` for an image " "classification task, instead got {}.".format(
+                type(model)
+            )
+        )
 
     if metrics is None:
-        metrics = ['map']
+        metrics = ["map"]
     elif isinstance(metrics, str):
         metrics = [metrics]
     if lr is None:
-        if kwargs.get('learning_rate', None) is not None:
-            lr = kwargs['learning_rate']
+        if kwargs.get("learning_rate", None) is not None:
+            lr = kwargs["learning_rate"]
         else:
             lr = 0.0002 if dataset.num_classes == 1 else 0.0008
     if optimizer is None:
-        optimizer = torch.optim.AdamW(model.parameters(), lr = lr)
-    elif lr is not None and kwargs.get('learning_rate', None) is not None:
+        optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+    elif lr is not None and kwargs.get("learning_rate", None) is not None:
         raise ValueError("You cannot pass both `lr` and `learning_rate`.")
 
     model._prepare_for_training(
-        metrics = metrics,
-        optimizer = optimizer,
-        lr_scheduler = lr_scheduler,
-        lr = lr,
+        metrics=metrics,
+        optimizer=optimizer,
+        lr_scheduler=lr_scheduler,
+        lr=lr,
     )
 
     # Set up the trainer.
@@ -671,61 +661,62 @@ def train_detection(model,
             os.makedirs(save_dir, exist_ok=True)
             log("Created directory ({}) for saving training logs.".format(save_dir))
     else:
-        save_dir = os.path.join(os.getcwd(), 'agml_training_logs')
+        save_dir = os.path.join(os.getcwd(), "agml_training_logs")
         if not os.path.exists(save_dir):
             os.makedirs(save_dir, exist_ok=True)
             log("Created directory ({}) for saving training logs.".format(save_dir))
     if experiment_name is None:
         curr_datetime = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M")
         if dataset_exists:
-            experiment_name = '{}_{}_{}'.format(
-                'object_detection', dataset_name, curr_datetime)  # noqa
+            experiment_name = "{}_{}_{}".format("object_detection", dataset_name, curr_datetime)  # noqa
         else:
-            experiment_name = '{}_{}_{}'.format(
-                'object_detection', 'unknown', curr_datetime)
+            experiment_name = "{}_{}_{}".format("object_detection", "unknown", curr_datetime)
     save_dir = os.path.join(save_dir, experiment_name)
     if loggers is not None:
         for _logger in loggers:
             if not isinstance(_logger, Logger):
-                raise ValueError("Expected a `pytorch_lightning.loggers.Logger` for a "
-                                 "logger, instead got {}.".format(type(_logger)))
+                raise ValueError(
+                    "Expected a `pytorch_lightning.loggers.Logger` for a " "logger, instead got {}.".format(
+                        type(_logger)
+                    )
+                )
     else:
-        loggers = [TensorBoardLogger(save_dir, name = experiment_name)]
-    checkpoint_callback = ModelCheckpoint(save_dir, monitor='val_map', mode='max', save_top_k=1)
+        loggers = [TensorBoardLogger(save_dir, name=experiment_name)]
+    checkpoint_callback = ModelCheckpoint(save_dir, monitor="val_map", mode="max", save_top_k=1)
 
-    accelerator = get_accelerator(use_cpu = use_cpu)
-    if accelerator == 'cuda':
+    accelerator = get_accelerator(use_cpu=use_cpu)
+    if accelerator == "cuda":
         try:  # newer pytorch versions
             from pytorch_lightning.accelerators import find_usable_cuda_devices
+
             devices = find_usable_cuda_devices()
         except ImportError:
-            accelerator = 'gpu'
-            devices = 'auto'
+            accelerator = "gpu"
+            devices = "auto"
     else:
-        devices = 'auto'
+        devices = "auto"
 
     trainer = Trainer(
-        max_epochs = epochs,
-        accelerator = accelerator,
-        devices = devices,
-        logger = loggers,
-        callbacks = [checkpoint_callback],
-        log_every_n_steps = 2,
+        max_epochs=epochs,
+        accelerator=accelerator,
+        devices=devices,
+        logger=loggers,
+        callbacks=[checkpoint_callback],
+        log_every_n_steps=2,
     )
 
     # Train and test the model.
     trainer.fit(
         model,
-        train_dataloaders = train_dataloader,
-        val_dataloaders = val_dataloader,
+        train_dataloaders=train_dataloader,
+        val_dataloaders=val_dataloader,
     )
 
     if test_dataloader is not None:
-        trainer.test(dataloaders = test_dataloader)
+        trainer.test(dataloaders=test_dataloader)
 
     # Get the saved path for the best model.
     best_model_path = checkpoint_callback.best_model_path
     log("The best model was saved to: {}".format(best_model_path))
 
     return model
-
diff --git a/agml/synthetic/__init__.py b/agml/synthetic/__init__.py
index d485c550..91abb4de 100644
--- a/agml/synthetic/__init__.py
+++ b/agml/synthetic/__init__.py
@@ -13,25 +13,10 @@
 # limitations under the License.
 
 
-from .options import (
-    HeliosOptions,
-    AnnotationType,
-    SimulationType
-)
-from .generator import (
-    HeliosDataGenerator
-)
-from .tools import (
-    generate_environment_map,
-    generate_camera_positions
-)
-from .compilation import (
-    recompile_helios
-)
-from .config import (
-    reinstall_helios,
-    available_canopies,
-    default_canopy_parameters
-)
-from .manual import generate_manual_data
+from .compilation import recompile_helios
+from .config import available_canopies, default_canopy_parameters, reinstall_helios
+from .generator import HeliosDataGenerator
 from .lidar_loader import LiDARDataLoader
+from .manual import generate_manual_data
+from .options import AnnotationType, HeliosOptions, SimulationType
+from .tools import generate_camera_positions, generate_environment_map
diff --git a/agml/synthetic/compilation.py b/agml/synthetic/compilation.py
index 961ac75d..aa0f31b2 100644
--- a/agml/synthetic/compilation.py
+++ b/agml/synthetic/compilation.py
@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import glob
 import os
 import re
-import sys
-import glob
 import shutil
-import tempfile
 import subprocess as sp
+import sys
+import tempfile
 from datetime import datetime as dt
 
 from agml.backend.config import _update_config, _get_config
@@ -36,82 +36,86 @@
     PROJECT_PATH, 'build', PROJECT)
 
 # Helios parameter paths.
-XML_PATH = os.path.join(PROJECT_PATH, 'xml')
+XML_PATH = os.path.join(PROJECT_PATH, "xml")
 
 
 def _update_cmake_and_project(lidar_enabled=False):
     """Updates the CMake + project file to enable or disable LiDAR compilation."""
-    cmake_file = os.path.join(PROJECT_PATH, 'CMakeLists.txt')
-    project_file = os.path.join(PROJECT_PATH, 'generate.cpp')
-    with open(cmake_file, 'r') as f:
+    cmake_file = os.path.join(PROJECT_PATH, "CMakeLists.txt")
+    project_file = os.path.join(PROJECT_PATH, "generate.cpp")
+    with open(cmake_file, "r") as f:
         default_cmake_contents = f.read()
-    with open(project_file, 'r') as f:
+    with open(project_file, "r") as f:
         default_project_contents = f.read()
     if lidar_enabled:
         # Update the imports and CMake file
-        if 'lidar' not in default_cmake_contents:  # add LiDAR to plugins
-            cmake_contents = re.sub(r'(set\s*\(\s*PLUGINS\s*")(\S*)("\s*\))', r'\1lidar;\2\3',
-                                    default_cmake_contents, flags=re.IGNORECASE)
+        if "lidar" not in default_cmake_contents:  # add LiDAR to plugins
+            cmake_contents = re.sub(
+                r'(set\s*\(\s*PLUGINS\s*")(\S*)("\s*\))',
+                r"\1lidar;\2\3",
+                default_cmake_contents,
+                flags=re.IGNORECASE,
+            )
         else:
             cmake_contents = default_cmake_contents
 
-        if '#include <LiDAR.h>' not in default_project_contents:
+        if "#include <LiDAR.h>" not in default_project_contents:
             project_contents = default_project_contents.replace(
-                '#include <Visualizer.h>',
-                '#include <Visualizer.h>\n#include <LiDAR.h>'
+                "#include <Visualizer.h>", "#include <Visualizer.h>\n#include <LiDAR.h>"
             )
         else:
             project_contents = default_project_contents
 
         # Uncomment the lines referencing LiDAR in the project file
-        project_lines = project_contents.split('\n')
+        project_lines = project_contents.split("\n")
         processed_project_lines = []
         for line in project_lines:
-            if 'lidar' in line.lower():
-                processed_project_lines.append(line.replace('// ', ''))
+            if "lidar" in line.lower():
+                processed_project_lines.append(line.replace("// ", ""))
             else:
                 processed_project_lines.append(line)
-        project_contents = '\n'.join(processed_project_lines)
+        project_contents = "\n".join(processed_project_lines)
 
     else:
         # Update the imports and CMake file
-        cmake_contents = re.sub('lidar;', '', default_cmake_contents)
-        project_contents = re.sub("#include .LiDAR\\.h.\n", '', default_project_contents)
+        cmake_contents = re.sub("lidar;", "", default_cmake_contents)
+        project_contents = re.sub("#include .LiDAR\\.h.\n", "", default_project_contents)
 
         # Comment out the lines referencing LiDAR in the project file
-        project_lines = project_contents.split('\n')
+        project_lines = project_contents.split("\n")
         processed_project_lines = []
         for line in project_lines:
-            if (re.search('[^\\"]lidarcloud[^\\"]', line)
-                    and not line.lstrip().startswith('//')
-                    and 'contains' not in line):
-                processed_project_lines.append('// ' + line)
+            if (
+                re.search('[^\\"]lidarcloud[^\\"]', line)
+                and not line.lstrip().startswith("//")
+                and "contains" not in line
+            ):
+                processed_project_lines.append("// " + line)
             else:
                 processed_project_lines.append(line)
-        project_contents = '\n'.join(processed_project_lines)
+        project_contents = "\n".join(processed_project_lines)
 
-    with open(cmake_file, 'w') as f:
+    with open(cmake_file, "w") as f:
         f.write(cmake_contents)
-    with open(project_file, 'w') as f:
+    with open(project_file, "w") as f:
         f.write(project_contents)
 
 
-def _compile_helios_default(cmake_build_type='Release',
-                            lidar_enabled=False,
-                            parallel=True):
+def _compile_helios_default(cmake_build_type="Release", lidar_enabled=False, parallel=True):
     """Compiles the default Helios library upon installation and update."""
     if not os.path.exists(PROJECT_PATH):
         raise NotADirectoryError(
             f"The expected project path {PROJECT_PATH} does not exist. "
             f"There may have been an error in installing Helios. Try "
-            f"re-installing it, or raise an issue with the AgML team.")
+            f"re-installing it, or raise an issue with the AgML team."
+        )
 
     # If there is an existing compiled version of Helios, then cache it
     # temporarily until the new compilation is complete. If an error is
     # encountered during the compilation, then we want to have a backup.
     os.makedirs(HELIOS_BUILD, exist_ok=True)
     temp_dir = tempfile.TemporaryDirectory()
-    helios_temp_dir = os.path.join(temp_dir.name, 'helios_build')
+    helios_temp_dir = os.path.join(temp_dir.name, "helios_build")
     shutil.move(HELIOS_BUILD, helios_temp_dir)
 
     try:
@@ -119,22 +123,24 @@ def _compile_helios_default(cmake_build_type='Release',
         _update_cmake_and_project(lidar_enabled=lidar_enabled)
 
         # Construct arguments for the compilation.
-        generator = 'NMake' if sys.platform == 'win32' else 'Unix'
-        cmake_args = ['cmake', '..', '-G', generator + ' Makefiles',
-                      f'-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={HELIOS_BUILD}',
-                      f'-DCMAKE_BUILD_TYPE={cmake_build_type}']
-        if not parallel or sys.platform == 'win32':
-            make_args = ['cmake', '--build', '.']
+        generator = "NMake" if sys.platform == "win32" else "Unix"
+        cmake_args = [
+            "cmake",
+            "..",
+            "-G",
+            generator + " Makefiles",
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={HELIOS_BUILD}",
+            f"-DCMAKE_BUILD_TYPE={cmake_build_type}",
+        ]
+        if not parallel or sys.platform == "win32":
+            make_args = ["cmake", "--build", "."]
         else:
-            make_args = ['make', f'-j{os.cpu_count()}']
+            make_args = ["make", f"-j{os.cpu_count()}"]
 
         # Create the log file and clear the existing one.
-        log_file = os.path.expanduser(
-            f"~/.agml/.helios_compilation_log"
-            f"-{dt.now().strftime('%Y%m%d-%H%M%S')}.log")
+        log_file = os.path.expanduser(f"~/.agml/.helios_compilation_log" f"-{dt.now().strftime('%Y%m%d-%H%M%S')}.log")
         try:
-            existing_log = glob.glob(os.path.expanduser(
-                '~/.agml/.helios_compilation_log-*.log'))[0]
+            existing_log = glob.glob(os.path.expanduser("~/.agml/.helios_compilation_log-*.log"))[0]
             os.remove(existing_log)
         except:
             pass
@@ -145,44 +151,56 @@ def _compile_helios_default(cmake_build_type='Release',
         # Compile the CMake files.
         cmake_log = ""
         sys.stderr.write("Compiling Helios with CMake.\n\n")
-        cmake_process = sp.Popen(cmake_args, stdout=sp.PIPE, cwd=HELIOS_BUILD,
-                                 stderr=sp.STDOUT, universal_newlines=True)
+        cmake_process = sp.Popen(
+            cmake_args,
+            stdout=sp.PIPE,
+            cwd=HELIOS_BUILD,
+            stderr=sp.STDOUT,
+            universal_newlines=True,
+        )
         for line in iter(cmake_process.stdout.readline, ""):
             cmake_log += line
             sys.stderr.write(line)
         cmake_process.stdout.close()
-        with open(log_file, 'a') as f:
+        with open(log_file, "a") as f:
             f.write(cmake_log)
         cmake_return = cmake_process.wait()
         if cmake_return != 0:
             sys.stderr.write(
-                f'\nEncountered an error when attempting to compile '
-                f'Helios with CMake. Please report this traceback to '
-                f'the AgML team. A full traceback of the compilation '
-                f'process can be found at "{log_file}".')
+                f"\nEncountered an error when attempting to compile "
+                f"Helios with CMake. Please report this traceback to "
+                f"the AgML team. A full traceback of the compilation "
+                f'process can be found at "{log_file}".'
+            )
             _compilation_failed(helios_temp_dir, temp_dir)
-        sys.stdout.write('\n')
-        sys.stderr.write('\n')
+        sys.stdout.write("\n")
+        sys.stderr.write("\n")
 
         # Generate the main executable.
         cmake_log = "\n"
         sys.stderr.write("Building Helios executable with CMake.\n\n")
-        make_process = sp.Popen(make_args, stdout=sp.PIPE, cwd=HELIOS_BUILD,
-                                stderr=sp.STDOUT, universal_newlines=True)
+        make_process = sp.Popen(
+            make_args,
+            stdout=sp.PIPE,
+            cwd=HELIOS_BUILD,
+            stderr=sp.STDOUT,
+            universal_newlines=True,
+        )
         for line in iter(make_process.stdout.readline, ""):
             cmake_log += line
             sys.stderr.write(line)
         make_process.stdout.close()
-        with open(log_file, 'a') as f:
+        with open(log_file, "a") as f:
             f.write(cmake_log)
         make_return = make_process.wait()
 
         if make_return != 0:
             sys.stderr.write(
-                f'\nEncountered an error when attempting to compile '
-                f'Helios with CMake. Please report this traceback to '
-                f'the AgML team. A full traceback of the compilation '
-                f'process can be found at "{log_file}".')
+                f"\nEncountered an error when attempting to compile "
+                f"Helios with CMake. Please report this traceback to "
+                f"the AgML team. A full traceback of the compilation "
+                f'process can be found at "{log_file}".'
+            )
             _compilation_failed(helios_temp_dir, temp_dir)
 
         # Print the final message.
@@ -199,21 +217,19 @@ def _compile_helios_executable_only(parallel):
         raise NotADirectoryError(
             f"The expected project path {PROJECT_PATH} does not exist. "
             f"There may have been an error in installing Helios. Try "
-            f"re-installing it, or raise an issue with the AgML team.")
+            f"re-installing it, or raise an issue with the AgML team."
+        )
 
     # Construct arguments for the compilation.
-    if not parallel or sys.platform == 'win32':
-        make_args = ['cmake', '--build', '.']
+    if not parallel or sys.platform == "win32":
+        make_args = ["cmake", "--build", "."]
     else:
-        make_args = ['make', f'-j{os.cpu_count()}']
+        make_args = ["make", f"-j{os.cpu_count()}"]
 
     # Create the log file and clear the existing one.
-    log_file = os.path.expanduser(
-        f"~/.agml/.helios_compilation_log"
-        f"-{dt.now().strftime('%Y%m%d-%H%M%S')}.log")
+    log_file = os.path.expanduser(f"~/.agml/.helios_compilation_log" f"-{dt.now().strftime('%Y%m%d-%H%M%S')}.log")
     try:
-        existing_log = glob.glob(os.path.expanduser(
-            '~/.agml/.helios_compilation_log-*.log'))[0]
+        existing_log = glob.glob(os.path.expanduser("~/.agml/.helios_compilation_log-*.log"))[0]
         os.remove(existing_log)
     except:
         pass
@@ -221,30 +237,33 @@ def _compile_helios_executable_only(parallel):
     # Generate the main executable.
     cmake_log = "\n"
     sys.stderr.write("Building Helios executable with CMake.\n\n")
-    make_process = sp.Popen(make_args, stdout=sp.PIPE, cwd=HELIOS_BUILD,
-                            stderr=sp.STDOUT, universal_newlines=True)
+    make_process = sp.Popen(
+        make_args,
+        stdout=sp.PIPE,
+        cwd=HELIOS_BUILD,
+        stderr=sp.STDOUT,
+        universal_newlines=True,
+    )
     for line in iter(make_process.stdout.readline, ""):
         cmake_log += line
         sys.stderr.write(line)
     make_process.stdout.close()
-    with open(log_file, 'a') as f:
+    with open(log_file, "a") as f:
         f.write(cmake_log)
     make_return = make_process.wait()
     if make_return != 0:
         sys.stderr.write(
-            f'\nEncountered an error when attempting to compile '
-            f'Helios with CMake. Please report this traceback to '
-            f'the AgML team. A full traceback of the compilation '
-            f'process can be found at "{log_file}".')
+            f"\nEncountered an error when attempting to compile "
+            f"Helios with CMake. Please report this traceback to "
+            f"the AgML team. A full traceback of the compilation "
+            f'process can be found at "{log_file}".'
+        )
 
     # Print the final message.
     _compilation_successful(lidar_enabled=None)
 
 
-def recompile_helios(executable_only=False,
-                     debug_mode=False,
-                     lidar_enabled=False,
-                     parallel=True):
+def recompile_helios(executable_only=False, debug_mode=False, lidar_enabled=False, parallel=True):
     """Recompiles the Helios library with the set parameters.
 
     This method can be used by the user in order to recompile Helios, if, for
@@ -270,34 +289,34 @@ def recompile_helios(executable_only=False,
         significantly faster compilation, at the cost of high CPU usage.
     """
     if executable_only and lidar_enabled:
-        raise ValueError("If you want to compile Helios with LiDAR support, "
-                         "you cannot compile only the executable.")
+        raise ValueError("If you want to compile Helios with LiDAR support, " "you cannot compile only the executable.")
     if executable_only and debug_mode:
-        raise ValueError("If you want to compile the build in `Debug` mode, "
-                         "you cannot compile only the executable.")
+        raise ValueError("If you want to compile the build in `Debug` mode, " "you cannot compile only the executable.")
     if executable_only:
         _compile_helios_executable_only(parallel=parallel)
     else:
-        cmake_build_type = 'Debug' if debug_mode else 'Release'
-        _compile_helios_default(cmake_build_type=cmake_build_type,
-                                lidar_enabled=lidar_enabled,
-                                parallel=parallel)
+        cmake_build_type = "Debug" if debug_mode else "Release"
+        _compile_helios_default(
+            cmake_build_type=cmake_build_type,
+            lidar_enabled=lidar_enabled,
+            parallel=parallel,
+        )
 
 
 def _compilation_successful(lidar_enabled):
     """Updates after successful Helios compilation."""
-    sys.stdout.write('\n')
-    sys.stderr.write('\nHelios compilation successful!\n')
+    sys.stdout.write("\n")
+    sys.stderr.write("\nHelios compilation successful!\n")
     if lidar_enabled is not None:
-        _update_config('lidar_enabled', lidar_enabled)
+        _update_config("lidar_enabled", lidar_enabled)
 
 
 def is_helios_compiled_with_lidar():
     """Returns whether Helios was compiled with LiDAR support enabled."""
     try:
-        return _get_config('lidar_enabled')
+        return _get_config("lidar_enabled")
     except:
-        _update_config('lidar_enabled', False)
+        _update_config("lidar_enabled", False)
         return False
 
 
diff --git a/agml/synthetic/config.py b/agml/synthetic/config.py
index 060b9805..1c097bb1 100644
--- a/agml/synthetic/config.py
+++ b/agml/synthetic/config.py
@@ -12,19 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import functools
+import json
+import math
 import os
 import re
-import sys
-import math
-import json
 import shutil
-import functools
 import subprocess as sp
+import sys
 from datetime import datetime as dt
 
 from agml.utils.io import recursive_dirname
 
-
 # If this file is imported multiple times, only run the check once.
 _HELIOS_CHECK_DONE_IN_SESSION = False
 
@@ -38,17 +37,17 @@
 LIDAR_SOURCE = os.path.join(HELIOS_PATH, 'plugins/lidar/src/LiDAR.cpp')
 
 # Path to the stored Helios configuration JSON file in root dir.
-HELIOS_CONFIG_FILE = os.path.expanduser('~/.agml/helios_config.json')
+HELIOS_CONFIG_FILE = os.path.expanduser("~/.agml/helios_config.json")
 
 
-@functools.lru_cache(maxsize = None)
+@functools.lru_cache(maxsize=None)
 def load_default_helios_configuration():
     """Loads the default Helios parameter configuration."""
-    with open(HELIOS_CONFIG_FILE, 'r') as f:
+    with open(HELIOS_CONFIG_FILE, "r") as f:
         return json.load(f)
 
 
-def reinstall_helios(force = False):
+def reinstall_helios(force=False):
     """Re-installs the Helios module from scratch.
 
     See `_check_helios_installation()` for a specific description of what
@@ -57,7 +56,7 @@ def reinstall_helios(force = False):
     """
     if not force:
         check = input("Are you sure you want to re-install Helios? [y|n] ")
-        if check != 'y':
+        if check != "y":
             print("Aborting re-installation")
             return
         else:
@@ -69,9 +68,11 @@ def reinstall_helios(force = False):
 
 def verify_helios(f):
     """This decorator wraps any methods which require Helios to be installed."""
+
     def verify(*args, **kwargs):
         _check_helios_installation()
         return f(*args, **kwargs)
+
     return verify
 
 
@@ -92,11 +93,8 @@ def _check_helios_installation():
     _HELIOS_CHECK_DONE_IN_SESSION = True
 
     # Get the path to the Helios installation file.
-    helios_file = os.path.join(
-        os.path.dirname(os.path.dirname(__file__)),
-        '_helios/helios_install.sh')
-    helios_dir = os.path.join(
-        os.path.dirname(helios_file), 'Helios')
+    helios_file = os.path.join(os.path.dirname(os.path.dirname(__file__)), "_helios/helios_install.sh")
+    helios_dir = os.path.join(os.path.dirname(helios_file), "Helios")
 
     # Run the installation/update. If the Helios directory is not found,
     # then run a clean installation. Otherwise, check if a new version of
@@ -107,18 +105,17 @@ def _check_helios_installation():
         sys.stderr.write("\t" + helios_dir + "\n")
 
         # Update the last check of the Git update.
-        with open(os.path.expanduser('~/.agml/config.json')) as f:
+        with open(os.path.expanduser("~/.agml/config.json")) as f:
             contents = json.load(f)
-        with open(os.path.expanduser('~/.agml/config.json'), 'w') as f:
-            contents['last_helios_check'] = dt.now().strftime("%B %d %Y %H:%M:%S")
-            json.dump(contents, f, indent = 4)
+        with open(os.path.expanduser("~/.agml/config.json"), "w") as f:
+            contents["last_helios_check"] = dt.now().strftime("%B %d %Y %H:%M:%S")
+            json.dump(contents, f, indent=4)
 
     else:
         # Check if the Git update check has been run in the last 48 hours.
-        with open(os.path.expanduser('~/.agml/config.json')) as f:
+        with open(os.path.expanduser("~/.agml/config.json")) as f:
             contents = json.load(f)
-        last_check = contents.get(
-            'last_helios_check', dt(1970, 1, 1).strftime("%B %d %Y %H:%M:%S"))
+        last_check = contents.get("last_helios_check", dt(1970, 1, 1).strftime("%B %d %Y %H:%M:%S"))
         last_check = dt.strptime(last_check, "%B %d %Y %H:%M:%S")
 
         # If the last check has been run less than 48 hours ago, then
@@ -128,12 +125,11 @@ def _check_helios_installation():
 
         # Check if there is a new version available.
         sys.stderr.write(
-            f"Last check for Helios update: over {(dt.now() - last_check).days} "
-            f"day(s) ago. Checking for update.\n")
+            f"Last check for Helios update: over {(dt.now() - last_check).days} " f"day(s) ago. Checking for update.\n"
+        )
 
     # Execute the installation/update script.
-    process = sp.Popen(['bash', helios_file],
-                       stdout = sp.PIPE, universal_newlines = True)
+    process = sp.Popen(["bash", helios_file], stdout=sp.PIPE, universal_newlines=True)
     for line in iter(process.stdout.readline, ""):
         sys.stderr.write(line)
     process.stdout.close()
@@ -143,120 +139,127 @@ def _check_helios_installation():
     _update_helios_parameters()
 
     # Copy the project files to the Helios directory.
-    project_dir = os.path.join(os.path.dirname(__file__), 'synthetic_data_generation')
-    output_dir = os.path.join(helios_dir, 'projects', 'SyntheticImageAnnotation')
+    project_dir = os.path.join(os.path.dirname(__file__), "synthetic_data_generation")
+    output_dir = os.path.join(helios_dir, "projects", "SyntheticImageAnnotation")
     if not os.path.exists(output_dir):
         shutil.copytree(project_dir, output_dir)
-        os.makedirs(os.path.join(output_dir, 'xml'), exist_ok = True)
+        os.makedirs(os.path.join(output_dir, "xml"), exist_ok=True)
 
     # Recompile Helios (with the prior configuration).
     from agml.synthetic.compilation import _compile_helios_default, is_helios_compiled_with_lidar
-    _compile_helios_default(lidar_enabled = is_helios_compiled_with_lidar())
+
+    _compile_helios_default(lidar_enabled=is_helios_compiled_with_lidar())
 
     # Update the latest check.
-    with open(os.path.expanduser('~/.agml/config.json')) as f:
+    with open(os.path.expanduser("~/.agml/config.json")) as f:
         contents = json.load(f)
-    with open(os.path.expanduser('~/.agml/config.json'), 'w') as f:
-        contents['last_helios_check'] = dt.now().strftime("%B %d %Y %H:%M:%S")
-        json.dump(contents, f, indent = 4)
+    with open(os.path.expanduser("~/.agml/config.json"), "w") as f:
+        contents["last_helios_check"] = dt.now().strftime("%B %d %Y %H:%M:%S")
+        json.dump(contents, f, indent=4)
 
     # Clear the outputs.
-    sys.stdout.write('\n')
-    sys.stderr.write('\n')
+    sys.stdout.write("\n")
+    sys.stderr.write("\n")
 
 
 def _update_helios_parameters():
     """Updates all default Helios parameters (canopy, camera, LiDAR).
-    
+
     Every time a new version of Helios is installed or updated, the default
     parameters need to be read from the Helios source files and updated in
     the local configuration file: `~/.agml/helios_config.json`.
     """
     params = {
-        'canopy': _get_canopy_params(),
-        'camera': _get_camera_params(),
-        'lidar': _get_lidar_params()
+        "canopy": _get_canopy_params(),
+        "camera": _get_camera_params(),
+        "lidar": _get_lidar_params(),
     }
 
     # Save the parameters to the configuration file.
-    with open(HELIOS_CONFIG_FILE, 'w') as f:
-        json.dump(params, f, indent = 4)
+    with open(HELIOS_CONFIG_FILE, "w") as f:
+        json.dump(params, f, indent=4)
 
 
 def _get_canopy_params():
     """Updates the default canopy generation parameters for Helios."""
     # Generate the canopy types.
-    with open(CANOPY_HEADER, 'r') as f:
+    with open(CANOPY_HEADER, "r") as f:
         canopy_header_lines = f.readlines()
     canopy_types = [
-        re.match('struct\\s(.*?){\\n', string).group(1).split('Parameters')[0]
-        for string in canopy_header_lines if 'struct ' in string
-        and not string.strip().startswith('/**') and not string.strip().startswith('//')]
+        re.match("struct\\s(.*?){\\n", string).group(1).split("Parameters")[0]
+        for string in canopy_header_lines
+        if "struct " in string and not string.strip().startswith("/**") and not string.strip().startswith("//")
+    ]
 
     # Generate the canopy parameters.
     with open(CANOPY_SOURCE) as f:
-        canopy_source_lines = f.read().replace('\n', '')
+        canopy_source_lines = f.read().replace("\n", "")
 
     # Add the default parameters for ground annotations.
-    canopy_parameters = {'Ground': {
-        'origin': [0.0, 0.0, 0.0],
-        'extent': [10.0, 10.0],
-        'texture_subtiles': [10.0, 10.0],
-        'texture_subpatches': [1.0, 1.0],
-        'ground_texture_file': 'plugins/canopygenerator/textures/dirt.jpg',
-        'rotation': 0.0}}
+    canopy_parameters = {
+        "Ground": {
+            "origin": [0.0, 0.0, 0.0],
+            "extent": [10.0, 10.0],
+            "texture_subtiles": [10.0, 10.0],
+            "texture_subpatches": [1.0, 1.0],
+            "ground_texture_file": "plugins/canopygenerator/textures/dirt.jpg",
+            "rotation": 0.0,
+        }
+    }
 
     # This regex is adapted from the following source:
     # https://stackoverflow.com/questions/943391/how-to-get-the-function-declaration-or-definitions-using-regex
     # It searches for all method definitions and then gets all of the content in the method.
     for content in re.finditer(
-            r"([A-Za-z]+)Parameters::\1Parameters\(\)\s*:\s*([A-Za-z]+)Parameters\(\)\s*{([^{}]*)}", canopy_source_lines):
+        r"([A-Za-z]+)Parameters::\1Parameters\(\)\s*:\s*([A-Za-z]+)Parameters\(\)\s*{([^{}]*)}",
+        canopy_source_lines,
+    ):
         # Ensure that we're only checking valid parameter methods.
-        name = content.group(0).replace('()', '').split('Parameters')[0]
+        name = content.group(0).replace("()", "").split("Parameters")[0]
         source = content.group(3)
 
         # Get all of the definitions by removing all spaces of at least length 2.
-        if any(i == name for i in canopy_types) and 'std::cout' not in source:  # noqa
+        if any(i == name for i in canopy_types) and "std::cout" not in source:  # noqa
             canopy_parameters[name] = {}
 
             # Ignore the methods which define the parameters from an XML file,
             # we only want the ones that read the default parameter values.
-            if 'readParametersFromXML' in source:
-                print('xml', name, source)
+            if "readParametersFromXML" in source:
+                print("xml", name, source)
                 continue
 
             definitions = [
-                s.replace(';', '') for s in re.split('[\\s]{2,}', source)
-                if s != '' and not s.startswith('//')]
+                s.replace(";", "") for s in re.split("[\\s]{2,}", source) if s != "" and not s.startswith("//")
+            ]
             for d in definitions:
                 # Ignore comments.
-                if d.startswith('//'):
+                if d.startswith("//"):
                     continue
 
                 # Split the name and the value.
-                n, value = d.split(' = ')
+                n, value = d.split(" = ")
 
                 # If the value is defined in a method, extract the method arguments.
-                if '(' in value:
-                    value = re.search('\\((.*?)\\)', value).group(1)
+                if "(" in value:
+                    value = re.search("\\((.*?)\\)", value).group(1)
 
                 # Remove unnecessary terms. The `.f` removal needs to be done using
                 # regex since we can't just remove regular `f` in case of paths,
                 # but we also can't just replace `.f` with `0` or `.0`.
-                value = value.replace(',', ' ').replace('\"', '')
-                value = re.sub('(\\.|\\d)f', r'\g<1>0', value)
-                value = re.sub('//.*?$', '', value)
+                value = value.replace(",", " ").replace('"', "")
+                value = re.sub("(\\.|\\d)f", r"\g<1>0", value)
+                value = re.sub("//.*?$", "", value)
 
                 # A specific case to replace values using pi.
-                value = value.strip().replace('  ', ' ')
-                if 'M_PI' in value:
-                    value = round(float(value.split('*')[0].strip()) * math.pi, 6)
+                value = value.strip().replace("  ", " ")
+                if "M_PI" in value:
+                    value = round(float(value.split("*")[0].strip()) * math.pi, 6)
 
                 # A specific case where the value is multiplying a float
                 # by another, already defined parameter value.)
-                elif '*' in value:
-                    value = value.split('*')
-                    if value[0].strip().replace('.', '').isdigit():
+                elif "*" in value:
+                    value = value.split("*")
+                    if value[0].strip().replace(".", "").isdigit():
                         value = float(value[0]) * canopy_parameters[name][value[1].strip()]
                     else:
                         value = canopy_parameters[name][value[0].strip()] * float(value[1])
@@ -264,10 +267,10 @@ def _get_canopy_params():
                 # Convert numerical values to numbers/lists, as necessary.
                 elif value.isnumeric():
                     value = int(value)
-                elif value.replace('.', '').isdigit():
+                elif value.replace(".", "").isdigit():
                     value = float(value)
-                elif ' ' in value:
-                    value_items = value.split(' ')
+                elif " " in value:
+                    value_items = value.split(" ")
                     if all(i.isdigit() for i in value_items):
                         value = [int(v) for v in value_items]
                     else:
@@ -275,24 +278,25 @@ def _get_canopy_params():
 
                 # If the value is a path, then make it absolute.
                 else:
-                    if value.endswith('.jpg') or value.endswith('.png'):
+                    if value.endswith(".jpg") or value.endswith(".png"):
                         value = os.path.join(HELIOS_PATH, value)
 
                 # Update the parameter dictionary.
                 canopy_parameters[name][n] = value
 
     # Return the two dictionaries.
-    return {'types': canopy_types, 'parameters': canopy_parameters}
+    return {"types": canopy_types, "parameters": canopy_parameters}
 
 
 def _get_camera_params():
     """Updates the default camera parameters for Helios."""
     # No files are read here, the parameters are hard-coded.
     camera_params = {
-        'image_resolution': [600, 400],
-        'camera_lookat': [0.0, 0.0, 1.0],
-        'camera_position': [0.0, -2.0, 1.0]}
-    return {'parameters': camera_params}
+        "image_resolution": [600, 400],
+        "camera_lookat": [0.0, 0.0, 1.0],
+        "camera_position": [0.0, -2.0, 1.0],
+    }
+    return {"parameters": camera_params}
 
 
 def _get_lidar_params():
@@ -307,8 +311,9 @@ def _get_lidar_params():
         "phiMax": 360,
         "exitDiameter": 0.0,
         "beamDivergence": 0.0,
-        "ASCII_format": "x y z"}
-    return {'parameters': lidar_params}
+        "ASCII_format": "x y z",
+    }
+    return {"parameters": lidar_params}
 
 
 ################## API FUNCTIONS FOR CONVENIENCE ##################
@@ -317,11 +322,10 @@ def _get_lidar_params():
 @verify_helios
 def available_canopies():
     """Returns a list of available canopies in Helios."""
-    return load_default_helios_configuration()['canopy']['types']
+    return load_default_helios_configuration()["canopy"]["types"]
 
 
 @verify_helios
 def default_canopy_parameters(canopy):
     """Returns the default canopy parameters for a given `canopy`."""
-    return load_default_helios_configuration()['canopy']['parameters'][canopy]
-
+    return load_default_helios_configuration()["canopy"]["parameters"][canopy]
diff --git a/agml/synthetic/converter.py b/agml/synthetic/converter.py
index 37e4ba05..cf7595a8 100644
--- a/agml/synthetic/converter.py
+++ b/agml/synthetic/converter.py
@@ -12,19 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
-import sys
 import glob
 import json
+import os
 import shutil
-from typing import List
+import sys
 from dataclasses import dataclass
 from datetime import datetime as dt
+from typing import List
 
 import cv2
 import numpy as np
 
-from agml.utils.io import recursive_dirname, get_dir_list, get_file_list
+from agml.utils.io import get_dir_list, get_file_list, recursive_dirname
 from agml.utils.logging import tqdm
 
 
@@ -68,20 +68,20 @@ def parse_metadata(self, dataset):
         # Locate the dataset and get its actual name.
         output_dir = self._locate_dataset(dataset)
         name = os.path.basename(output_dir)
-        meta = {'path': output_dir, 'name': name}
-        meta_dir = os.path.join(output_dir, '.metadata')
+        meta = {"path": output_dir, "name": name}
+        meta_dir = os.path.join(output_dir, ".metadata")
 
         # Get the annotation type and the labels from the configuration file.
-        with open(os.path.join(meta_dir, f'config_{name}.txt'), 'r') as f:
+        with open(os.path.join(meta_dir, f"config_{name}.txt"), "r") as f:
             contents = [i.replace("\n", "") for i in f.readlines()]
-            meta['annotation_type'] = contents[1]
-            meta['labels'] = contents[3].split(' ')
+            meta["annotation_type"] = contents[1]
+            meta["labels"] = contents[3].split(" ")
 
         # Get the image resolution and date created from the metadata file.
-        with open(os.path.join(meta_dir, 'meta.json'), 'r') as f:
+        with open(os.path.join(meta_dir, "meta.json"), "r") as f:
             contents = json.load(f)
-            meta['image_size'] = contents['image_size']
-            meta['generation_date'] = contents['generation_date']
+            meta["image_size"] = contents["image_size"]
+            meta["generation_date"] = contents["generation_date"]
 
         # Return the options.
         return DataFormatConverterMetadata(**meta)
@@ -90,13 +90,14 @@ def parse_metadata(self, dataset):
     def _locate_dataset(name):
         if os.path.exists(name) and os.path.isdir(name):
             return name
-        syn_path = os.path.join(os.path.expanduser('~/.agml/synthetic'), name)
+        syn_path = os.path.join(os.path.expanduser("~/.agml/synthetic"), name)
         if os.path.exists(syn_path) and os.path.isdir(syn_path):
             return syn_path
         raise NotADirectoryError(
             f"The provided dataset `{name}` is not a path, "
             f"and if it were to be the name of a dataset, "
-            f"then {syn_path} does not exist either.")
+            f"then {syn_path} does not exist either."
+        )
 
     def convert(self):
         """Runs the data format conversion for the input Helios dataset.
@@ -118,7 +119,7 @@ def convert(self):
 
         # Otherwise, we need to reconstruct the entire structure and generate
         # the proper annotation format from the input files at the location.
-        if self._meta.annotation_type == 'object_detection':
+        if self._meta.annotation_type == "object_detection":
             try:
                 self._convert_object_detection_dataset()
             except Exception as e:
@@ -126,7 +127,7 @@ def convert(self):
                 raise e
             else:
                 self._remove_existing_image_dirs()
-        elif self._meta.annotation_type == 'semantic_segmentation':
+        elif self._meta.annotation_type == "semantic_segmentation":
             try:
                 self._convert_semantic_segmentation_dataset()
             except Exception as e:
@@ -138,22 +139,19 @@ def convert(self):
 
     def _convert_no_annotation_dataset(self):
         """For datasets with no annotations, this just moves the images."""
-        jpeg_images = glob.glob(
-            os.path.join(self._meta.path, "image*/**/*.jpeg"), recursive = True)
-        self._map_and_move_images(jpeg_images, output_dir = self._meta.path)
+        jpeg_images = glob.glob(os.path.join(self._meta.path, "image*/**/*.jpeg"), recursive=True)
+        self._map_and_move_images(jpeg_images, output_dir=self._meta.path)
 
     def _convert_object_detection_dataset(self):
         """Converts the format of an object detection dataset to COCO JSON."""
         # Get all of the images in the dataset.
-        jpeg_images = glob.glob(
-            os.path.join(self._meta.path, "image*/**/*.jpeg"), recursive = True)
+        jpeg_images = glob.glob(os.path.join(self._meta.path, "image*/**/*.jpeg"), recursive=True)
 
         # For each of the images, get their corresponding annotations.
         image_annotation_map = {}
         for image in jpeg_images:
             image_dir = os.path.dirname(image)
-            image_annotation_map[image] = \
-                self._convert_text_files_to_object_annotations(image_dir)
+            image_annotation_map[image] = self._convert_text_files_to_object_annotations(image_dir)
 
         # Create a virtual output directory structure and the new filenames.
         self._create_output_directory_structure()
@@ -166,9 +164,14 @@ def _convert_object_detection_dataset(self):
         for indx, image in enumerate(image_annotation_map.keys()):
             image_id_map[image] = indx + 1
             fpath = os.path.basename(image_new_map[image])
-            image_coco.append({
-                'file_name': fpath, 'width': self._meta.image_size[0],
-                'height': self._meta.image_size[1], 'id': indx + 1})
+            image_coco.append(
+                {
+                    "file_name": fpath,
+                    "width": self._meta.image_size[0],
+                    "height": self._meta.image_size[1],
+                    "id": indx + 1,
+                }
+            )
 
         # Generate the annotation COCO JSON contents.
         annotation_coco = []
@@ -176,32 +179,48 @@ def _convert_object_detection_dataset(self):
             image_box_tracker = 1
             for label, bboxes in annotation.items():
                 for box in bboxes:
-                    annotation_coco.append({
-                        'bbox': box.tolist(), 'area': int(box[2] * box[3]),
-                        'category_id': label, 'image_id': image_id_map[image],
-                        'id': image_box_tracker, 'iscrowd': 0, 'ignore': 0,
-                        'segmentation': []})
+                    annotation_coco.append(
+                        {
+                            "bbox": box.tolist(),
+                            "area": int(box[2] * box[3]),
+                            "category_id": label,
+                            "image_id": image_id_map[image],
+                            "id": image_box_tracker,
+                            "iscrowd": 0,
+                            "ignore": 0,
+                            "segmentation": [],
+                        }
+                    )
                     image_box_tracker += 1
 
         # Create the category mapping and the meta information.
-        category_coco = [
-            {'name': name, 'supercategory': 'none', 'id': i}
-            for i, name in enumerate(self._meta.labels)]
+        category_coco = [{"name": name, "supercategory": "none", "id": i} for i, name in enumerate(self._meta.labels)]
         info_coco = {
-            'description': f"{self._meta.name}: Helios-generated dataset",
-            'url': 'None', 'version': '1.0', 'year': dt.now().year,
-            'contributor': 'None', 'date_created': self._meta.generation_date}
+            "description": f"{self._meta.name}: Helios-generated dataset",
+            "url": "None",
+            "version": "1.0",
+            "year": dt.now().year,
+            "contributor": "None",
+            "date_created": self._meta.generation_date,
+        }
 
         # Save the JSON file with the annotations.
-        with open(os.path.join(self._meta.path, 'annotations.json'), 'w') as f:
-            json.dump({
-                'images': image_coco, 'annotations': annotation_coco,
-                'categories': category_coco, 'info': info_coco}, f, indent = 4)
+        with open(os.path.join(self._meta.path, "annotations.json"), "w") as f:
+            json.dump(
+                {
+                    "images": image_coco,
+                    "annotations": annotation_coco,
+                    "categories": category_coco,
+                    "info": info_coco,
+                },
+                f,
+                indent=4,
+            )
 
     def _convert_text_files_to_object_annotations(self, image_dir):
         """Converts text file annotations to COCO JSON object annotations."""
         width, height = self._meta.image_size
-        txt_fmt = os.path.join(image_dir, 'rectangular_labels_{0}.txt')
+        txt_fmt = os.path.join(image_dir, "rectangular_labels_{0}.txt")
 
         # Read each of the files corresponding to the given labels.
         bboxes = {}
@@ -211,18 +230,18 @@ def _convert_text_files_to_object_annotations(self, image_dir):
             if not os.path.exists(path):
                 err = FileNotFoundError(
                     f"The annotation file {path} for the label `{label}` "
-                    f"for the image at {image_dir} does not exist. ")
-                if label == 'fruits':
-                    path = txt_fmt.format('clusters')
+                    f"for the image at {image_dir} does not exist. "
+                )
+                if label == "fruits":
+                    path = txt_fmt.format("clusters")
                     if not os.path.exists(path):
                         raise err
                 else:
                     raise err
 
             # Read the text file and get all of the lines in float format.
-            with open(path, 'r') as f:
-                annotations = np.array(
-                    [line.replace('\n', '').strip().split(' ') for line in f.readlines()])
+            with open(path, "r") as f:
+                annotations = np.array([line.replace("\n", "").strip().split(" ") for line in f.readlines()])
 
             if len(annotations) > 0:
                 annotations = annotations[:, 1:].astype(np.float32)
@@ -243,23 +262,23 @@ def _convert_text_files_to_object_annotations(self, image_dir):
 
     def _create_output_directory_structure(self):
         """Builds the output directory structure for the dataset."""
-        if self._meta.annotation_type == 'object_detection':
+        if self._meta.annotation_type == "object_detection":
             data_dir = self._meta.path
-            image_dir = os.path.join(data_dir, 'images')
-            os.makedirs(image_dir, exist_ok = True)
-        elif self._meta.annotation_type == 'semantic_segmentation':
+            image_dir = os.path.join(data_dir, "images")
+            os.makedirs(image_dir, exist_ok=True)
+        elif self._meta.annotation_type == "semantic_segmentation":
             data_dir = self._meta.path
-            image_dir = os.path.join(data_dir, 'images')
-            os.makedirs(image_dir, exist_ok = True)
-            annotation_dir = os.path.join(data_dir, 'annotations')
-            os.makedirs(annotation_dir, exist_ok = True)
+            image_dir = os.path.join(data_dir, "images")
+            os.makedirs(image_dir, exist_ok=True)
+            annotation_dir = os.path.join(data_dir, "annotations")
+            os.makedirs(annotation_dir, exist_ok=True)
 
-    def _map_and_move_images(self, images, output_dir = None):
+    def _map_and_move_images(self, images, output_dir=None):
         """Maps all of the images to a new ID and moves them."""
         image_new_map = {}
         if output_dir is None:
-            output_dir = os.path.join(self._meta.path, 'images')
-        for image in tqdm(images, file = sys.stdout, desc = "Moving Images"):
+            output_dir = os.path.join(self._meta.path, "images")
+        for image in tqdm(images, file=sys.stdout, desc="Moving Images"):
             image_num = os.path.basename(recursive_dirname(image, 2))
             view_num = os.path.basename(recursive_dirname(image, 1))
             image_name = f"{image_num}-{view_num}.jpeg"
@@ -269,16 +288,15 @@ def _map_and_move_images(self, images, output_dir = None):
 
     def _cleanup_failed_object_detection_conversion(self):
         """Cleans up the remnants of a failed conversion for object detection."""
-        if os.path.exists(os.path.join(self._meta.path, 'annotations.json')):
-            os.remove(os.path.join(self._meta.path, 'annotations.json'))
-        if os.path.exists(os.path.join(self._meta.path, 'images')):
-            shutil.rmtree(os.path.join(self._meta.path, 'images'))
+        if os.path.exists(os.path.join(self._meta.path, "annotations.json")):
+            os.remove(os.path.join(self._meta.path, "annotations.json"))
+        if os.path.exists(os.path.join(self._meta.path, "images")):
+            shutil.rmtree(os.path.join(self._meta.path, "images"))
 
     def _convert_semantic_segmentation_dataset(self):
         """Converts the format of a semantic segmentation dataset to AgML's format."""
         # Get all of the images in the dataset.
-        jpeg_images = glob.glob(
-            os.path.join(self._meta.path, "image*/**/*.jpeg"), recursive = True)
+        jpeg_images = glob.glob(os.path.join(self._meta.path, "image*/**/*.jpeg"), recursive=True)
 
         # For each of the images, get their corresponding annotations.
         num_to_label = None
@@ -286,37 +304,38 @@ def _convert_semantic_segmentation_dataset(self):
         for image in jpeg_images:
             if num_to_label is None:
                 num_to_label = self._get_number_to_label_map(
-                    os.path.join(os.path.dirname(image),
-                                 'semantic_segmentation_ID_mapping.txt'))
-            image_annotation_map[image] = \
-                self._convert_text_to_semantic_segmentation_array(
-                    os.path.join(os.path.dirname(image), 'semantic_segmentation.txt'))
+                    os.path.join(os.path.dirname(image), "semantic_segmentation_ID_mapping.txt")
+                )
+            image_annotation_map[image] = self._convert_text_to_semantic_segmentation_array(
+                os.path.join(os.path.dirname(image), "semantic_segmentation.txt")
+            )
 
         # Create a virtual output directory structure and the new filenames.
         self._create_output_directory_structure()
         new_image_map = self._map_and_move_images(jpeg_images)
 
         # Write all of the corresponding annotations.
-        annotation_dir = os.path.join(self._meta.path, 'annotations')
+        annotation_dir = os.path.join(self._meta.path, "annotations")
         for image in jpeg_images:
             new_file = os.path.join(
-                annotation_dir, os.path.basename(
-                    new_image_map[image].replace('.jpeg', '.png')))
+                annotation_dir,
+                os.path.basename(new_image_map[image].replace(".jpeg", ".png")),
+            )
             cv2.imwrite(new_file, image_annotation_map[image])
 
     @staticmethod
     def _get_number_to_label_map(txt):
-        with open(txt, 'r') as f:
-            return [{int(float(v)): k for k, v in [
-                i.replace('\n', '').split(' ') for i in f.readlines()[1:]]}]
+        with open(txt, "r") as f:
+            return [{int(float(v)): k for k, v in [i.replace("\n", "").split(" ") for i in f.readlines()[1:]]}]
 
     @staticmethod
     def _convert_text_to_semantic_segmentation_array(file):
         """Converts a text file to a semantic segmentation array."""
         # Get all of the contents of the file, and convert them from strings to arrays.
-        with open(file, 'r') as f:
-            contents = [[i for i in line.replace('\n', '').split(' ') if i != '']
-                        for line in f.readlines() if line != '']
+        with open(file, "r") as f:
+            contents = [
+                [i for i in line.replace("\n", "").split(" ") if i != ""] for line in f.readlines() if line != ""
+            ]
             contents = np.array(contents).astype(np.int32)
 
         # Replace all extra values with zeroes.
@@ -327,44 +346,39 @@ def _convert_text_to_semantic_segmentation_array(file):
 
     def _cleanup_failed_semantic_segmentation_conversion(self):
         """Cleans up the remnants of a failed conversion for semantic segmentation."""
-        if os.path.exists(os.path.join(self._meta.path, 'images')):
-            shutil.rmtree(os.path.join(self._meta.path, 'images'))
-        if os.path.exists(os.path.join(self._meta.path, 'annotations')):
-            shutil.rmtree(os.path.join(self._meta.path, 'annotations'))
+        if os.path.exists(os.path.join(self._meta.path, "images")):
+            shutil.rmtree(os.path.join(self._meta.path, "images"))
+        if os.path.exists(os.path.join(self._meta.path, "annotations")):
+            shutil.rmtree(os.path.join(self._meta.path, "annotations"))
 
     def _remove_existing_image_dirs(self):
         """Removes the original image directories after a successful conversion."""
-        image_dirs = [
-            dir_ for dir_ in get_dir_list(self._meta.path) if dir_[-1].isnumeric()]
+        image_dirs = [dir_ for dir_ in get_dir_list(self._meta.path) if dir_[-1].isnumeric()]
         for image_dir in image_dirs:
             shutil.rmtree(os.path.join(self._meta.path, image_dir))
 
     @staticmethod
     def _infer_ag_task(ml_task):
-        if ml_task == 'object_detection':
-            return 'fruit_detection'
-        elif ml_task == 'semantic_segmentation':
-            return 'fruit_segmentation'
+        if ml_task == "object_detection":
+            return "fruit_detection"
+        elif ml_task == "semantic_segmentation":
+            return "fruit_segmentation"
 
     def _make_agml_info_json(self):
         """Constructs a JSON file with information for an AgMLDataLoader"""
         info_json = {
-            'classes': self._meta.labels,
-            'ml_task': self._meta.annotation_type,
-            'ag_task': self._infer_ag_task(self._meta.annotation_type),
-            'location': 'synthetic',
-            'sensor_modality': 'rgb',
-            'real_synthetic': 'synthetic',
-            'n_images': len(get_file_list(os.path.join(self._meta.path, 'images'))),
-            'platform': 'ground',
-            'input_data_format': 'jpeg',
-            'annotation_format': 'coco_json'
-            if self._meta.annotation_type in ['object_detection'] else 'image'
+            "classes": self._meta.labels,
+            "ml_task": self._meta.annotation_type,
+            "ag_task": self._infer_ag_task(self._meta.annotation_type),
+            "location": "synthetic",
+            "sensor_modality": "rgb",
+            "real_synthetic": "synthetic",
+            "n_images": len(get_file_list(os.path.join(self._meta.path, "images"))),
+            "platform": "ground",
+            "input_data_format": "jpeg",
+            "annotation_format": "coco_json" if self._meta.annotation_type in ["object_detection"] else "image",
         }
 
         # Save the info JSON to a file.
-        with open(os.path.join(self._meta.path, '.metadata', 'agml_info.json'), 'w') as f:
+        with open(os.path.join(self._meta.path, ".metadata", "agml_info.json"), "w") as f:
             json.dump(info_json, f)
-
-
-
diff --git a/agml/synthetic/generator.py b/agml/synthetic/generator.py
index fedbdd89..d7bb96bb 100644
--- a/agml/synthetic/generator.py
+++ b/agml/synthetic/generator.py
@@ -12,30 +12,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
+import datetime
 import io
-import shutil
-import sys
 import json
-import datetime
+import os
+import shutil
 import subprocess as sp
-from dataclasses import dataclass
+import sys
 import xml.etree.ElementTree as ET
 from collections.abc import Sequence
+from dataclasses import dataclass
 from typing import List, Union
 
 from dict2xml import dict2xml
 
-from agml.framework import AgMLSerializable
 from agml.backend.config import synthetic_data_save_path
-from agml.synthetic.options import HeliosOptions
-from agml.synthetic.options import AnnotationType, SimulationType
-from agml.synthetic.config import load_default_helios_configuration, verify_helios
+from agml.framework import AgMLSerializable
 from agml.synthetic.compilation import (
-    HELIOS_BUILD, HELIOS_EXECUTABLE, XML_PATH, PROJECT_PATH,
-    recompile_helios, is_helios_compiled_with_lidar
+    HELIOS_BUILD,
+    HELIOS_EXECUTABLE,
+    PROJECT_PATH,
+    XML_PATH,
+    is_helios_compiled_with_lidar,
+    recompile_helios,
 )
+from agml.synthetic.config import load_default_helios_configuration, verify_helios
 from agml.synthetic.converter import HeliosDataFormatConverter
+from agml.synthetic.options import AnnotationType, HeliosOptions, SimulationType
 from agml.utils.logging import log
 
 
@@ -60,7 +63,8 @@ def __post_init__(self):
                 "or corresponding string for 'annotation_type'. "
                 "Valid annotation types: `object_detection`, "
                 "`semantic_segmentation`, `instance_segmentation`, "
-                "or for no annotations at all, `none`.")
+                "or for no annotations at all, `none`."
+            )
 
         try:
             self.simulation_type = SimulationType(self.simulation_type)
@@ -68,15 +72,17 @@ def __post_init__(self):
             raise ValueError(
                 "Expected either a `SimulationType` parameter "
                 "or corresponding string for 'simulation_type'. "
-                "Valid simulation types: rgb`, `lidar`.")
+                "Valid simulation types: rgb`, `lidar`."
+            )
 
-        valid_labels = ['trunks', 'leaves', 'fruits', 'branches']
+        valid_labels = ["trunks", "leaves", "fruits", "branches"]
         if not all(i in valid_labels for i in self.labels):
-            raise ValueError(f"Got one or more invalid labels: {self.labels}."
-                             f"Valid labels: {[*valid_labels]}.")
-        if self.canopy in ['Tomato', 'Strawberry'] and 'trunks' in self.labels:
-            raise ValueError("Tomato and Strawberry canopies do not have any trunks, "
-                             "so trying to use the `trunks` label is impossible.")
+            raise ValueError(f"Got one or more invalid labels: {self.labels}." f"Valid labels: {[*valid_labels]}.")
+        if self.canopy in ["Tomato", "Strawberry"] and "trunks" in self.labels:
+            raise ValueError(
+                "Tomato and Strawberry canopies do not have any trunks, "
+                "so trying to use the `trunks` label is impossible."
+            )
 
     @classmethod
     def _empty(cls):
@@ -104,16 +110,15 @@ class HeliosDataGenerator(AgMLSerializable):
         A specific canopy to generate images for. This can be passed for
         in place of `options` to initialize the default options.
     """
+
     @verify_helios
-    def __init__(self, options: HeliosOptions = None, *, canopy = None):
+    def __init__(self, options: HeliosOptions = None, *, canopy=None):
         if options is None and canopy is not None:
             self._options = HeliosOptions(canopy)
         elif options is not None and canopy is None:
             self._options = options
         else:
-            raise ValueError(
-                "The `HeliosDataGenerator` needs either "
-                "a set of `HeliosOptions` or a `canopy`.")
+            raise ValueError("The `HeliosDataGenerator` needs either " "a set of `HeliosOptions` or a `canopy`.")
         self._canopy = self._options._canopy
 
         # Rather than constantly passing the different parameters used during
@@ -136,7 +141,7 @@ def options(self, value: HeliosOptions):
     @staticmethod
     def _sanitize_name(name):
         """Cleans a name to represent a valid folder destination."""
-        return name.replace(' ', '-').replace('~', '-')
+        return name.replace(" ", "-").replace("~", "-")
 
     def _convert_options_to_xml(self):
         """Converts the `HeliosOptions` parameters to XML format."""
@@ -146,62 +151,70 @@ def _convert_options_to_xml(self):
         # appears to generate images with twice the provided resolution,
         # so in order to fix this, we need to divide the resolution in
         # two here so that it is correct during generation.
-        parameters['camera']['image_resolution'] = \
-            [i // 2 for i in parameters['camera']['image_resolution']]
+        parameters["camera"]["image_resolution"] = [i // 2 for i in parameters["camera"]["image_resolution"]]
 
         # Generate the ground parameters.
         ground_params = self._load_ground_parameters()
-        parameters['Ground'] = ground_params
+        parameters["Ground"] = ground_params
 
         # The `scan` tag is used for LiDAR generation. This must be added later
         # because there can be multiple origins and thus multiple `scan` tags.
-        if self._generation_options.simulation_type == SimulationType.LiDAR or self._generation_options.simulation_type == SimulationType.Both:
+        if (
+            self._generation_options.simulation_type == SimulationType.LiDAR
+            or self._generation_options.simulation_type == SimulationType.Both
+        ):
             scan_tags = []
-            if isinstance(parameters['lidar']['origin'][0], list):
-                for origin in parameters['lidar']['origin']:
-                    scan_tag = parameters['lidar']
-                    scan_tag['origin'] = origin
+            if isinstance(parameters["lidar"]["origin"][0], list):
+                for origin in parameters["lidar"]["origin"]:
+                    scan_tag = parameters["lidar"]
+                    scan_tag["origin"] = origin
                     scan_tags.append(scan_tag)
             else:
-                scan_tags.append(parameters['lidar'])
+                scan_tags.append(parameters["lidar"])
 
         # Convert the canopy parameters to the Helios string format.
         self._convert_dict_params_to_string(parameters)
 
         # Create a fresh dictionary and put all of the parameters in it.
         canopy_parameters = {
-            self._canopy + "Parameters": parameters['canopy'],
-            'Ground': parameters['Ground']}
-        xml_params = {'canopygenerator': canopy_parameters}
-        if self._generation_options.simulation_type == SimulationType.RGB or self._generation_options.simulation_type == SimulationType.Both:
-            xml_params[''] = parameters['camera']
+            self._canopy + "Parameters": parameters["canopy"],
+            "Ground": parameters["Ground"],
+        }
+        xml_params = {"canopygenerator": canopy_parameters}
+        if (
+            self._generation_options.simulation_type == SimulationType.RGB
+            or self._generation_options.simulation_type == SimulationType.Both
+        ):
+            xml_params[""] = parameters["camera"]
 
         # Convert all of the parameters to XML format.
-        tree = ET.parse(io.StringIO(dict2xml({'helios': xml_params})))
+        tree = ET.parse(io.StringIO(dict2xml({"helios": xml_params})))
         root = tree.getroot()
 
         # Add the `scan` tags if necessary for LiDAR generation.
-        if self._generation_options.simulation_type == SimulationType.LiDAR or self._generation_options.simulation_type == SimulationType.Both:
-            for scan_tag in scan_tags: # noqa
-                scan_tag_contents = ET.parse(
-                    io.StringIO(dict2xml({'scan': scan_tag}))).getroot()
+        if (
+            self._generation_options.simulation_type == SimulationType.LiDAR
+            or self._generation_options.simulation_type == SimulationType.Both
+        ):
+            for scan_tag in scan_tags:  # noqa
+                scan_tag_contents = ET.parse(io.StringIO(dict2xml({"scan": scan_tag}))).getroot()
                 ET.indent(scan_tag_contents)
                 root.append(scan_tag_contents)
 
         # Update the camera tags.
         for child in root:
-            if child.tag == 'camera_position':
-                child.tag = 'globaldata_vec3'
-                child.set('label', 'camera_position')
-            if child.tag == 'camera_lookat':
-                child.tag = 'globaldata_vec3'
-                child.set('label', 'camera_lookat')
-            if child.tag == 'image_resolution':
-                child.tag = 'globaldata_int2'
-                child.set('label', 'image_resolution')
+            if child.tag == "camera_position":
+                child.tag = "globaldata_vec3"
+                child.set("label", "camera_position")
+            if child.tag == "camera_lookat":
+                child.tag = "globaldata_vec3"
+                child.set("label", "camera_lookat")
+            if child.tag == "image_resolution":
+                child.tag = "globaldata_int2"
+                child.set("label", "image_resolution")
 
         # Return the modified tree.
-        ET.indent(tree, '    ')
+        ET.indent(tree, "    ")
         return tree
 
     @staticmethod
@@ -209,24 +222,20 @@ def _convert_dict_params_to_string(d):
         """Converts dictionary int/float parameters to strings."""
         for key, value in d.items():
             for param, param_value in value.items():
-                if isinstance(param_value, Sequence) \
-                        and not isinstance(param_value, str):
+                if isinstance(param_value, Sequence) and not isinstance(param_value, str):
                     if isinstance(param_value[0], Sequence):
-                        param_value = [str(a).replace(",", "").replace(
-                            "[", " ").replace("]", "") for a in param_value]
-                        value[param] = \
-                            f' {" ".join(param_value)} '
+                        param_value = [str(a).replace(",", "").replace("[", " ").replace("]", "") for a in param_value]
+                        value[param] = f' {" ".join(param_value)} '
                     else:
-                        value[param] = \
-                            f' {" ".join([str(a) for a in param_value])} '
+                        value[param] = f' {" ".join([str(a) for a in param_value])} '
                 else:
-                    value[param] = f' {str(param_value)} '
+                    value[param] = f" {str(param_value)} "
 
     @staticmethod
     def _load_ground_parameters():
         """Loads the parameters for the `Ground` plant type."""
         cfg = load_default_helios_configuration()
-        return cfg['canopy']['parameters']['Ground']
+        return cfg["canopy"]["parameters"]["Ground"]
 
     @staticmethod
     def _parse_output_path(output_path: str, clear_existing_files: bool):
@@ -234,15 +243,16 @@ def _parse_output_path(output_path: str, clear_existing_files: bool):
         if os.path.exists(output_path) and os.path.isdir(output_path):
             if any(os.scandir(output_path)):
                 if clear_existing_files:
-                    log(f"Existing files found in the output directory "
-                        f"`{output_path}`, clearing the directory.")
+                    log(f"Existing files found in the output directory " f"`{output_path}`, clearing the directory.")
                     shutil.rmtree(output_path)
                     os.makedirs(output_path)
                 else:
-                    raise OSError(f"The provided directory for generation, "
-                                  f"'{output_path}', is not empty. Please "
-                                  f"clear out the contents of this directory "
-                                  f"and try again.")
+                    raise OSError(
+                        f"The provided directory for generation, "
+                        f"'{output_path}', is not empty. Please "
+                        f"clear out the contents of this directory "
+                        f"and try again."
+                    )
         else:
             os.makedirs(output_path)
 
@@ -250,22 +260,27 @@ def _write_config(self, *, cfg_file, xml_file):
         """Writes the config file that Helios loads from."""
         # Construct the string with the output.
         xml_file = os.path.realpath(xml_file)
-        cfg = f"{self._generation_options.num_images}\n" \
-              f"{' '.join([i.value for i in self._generation_options.annotation_type])}\n" \
-              f"{self._generation_options.simulation_type.value}\n" \
-              f"{' '.join(self._generation_options.labels)}\n" \
-              f"{xml_file}\n{self._generation_options.output_dir}"
+        cfg = (
+            f"{self._generation_options.num_images}\n"
+            f"{' '.join([i.value for i in self._generation_options.annotation_type])}\n"
+            f"{self._generation_options.simulation_type.value}\n"
+            f"{' '.join(self._generation_options.labels)}\n"
+            f"{xml_file}\n{self._generation_options.output_dir}"
+        )
 
         # Write the configuration file to its output path.
-        with open(os.path.join(PROJECT_PATH, cfg_file), 'w') as f:
+        with open(os.path.join(PROJECT_PATH, cfg_file), "w") as f:
             f.write(cfg)
 
-    def generate(self, *,
-                 name: str = None,
-                 num_images: int = 5,
-                 output_dir: os.PathLike = None,
-                 convert_data: bool = True,
-                 clear_existing_files: bool = False):
+    def generate(
+        self,
+        *,
+        name: str = None,
+        num_images: int = 5,
+        output_dir: os.PathLike = None,
+        convert_data: bool = True,
+        clear_existing_files: bool = False,
+    ):
         """Generates a batch of synthetic data using Helios.
 
         This method is the one which conducts the actual data generation using
@@ -352,8 +367,8 @@ def generate(self, *,
         if name is not None:
             name = self._sanitize_name(name)
         else:
-            date = datetime.datetime.now().strftime('%m%d%Y-%H%M')
-            name = f'helios-{date}'
+            date = datetime.datetime.now().strftime("%m%d%Y-%H%M")
+            name = f"helios-{date}"
 
         # Construct the output path of the dataset.
         if output_dir is not None:
@@ -371,21 +386,22 @@ def generate(self, *,
         # Construct the `GenerationInstanceOptions` class from the `HeliosOptions`
         # parameters and the newly passed input parameters.
         self._generation_options = GenerationInstanceOptions(
-            canopy = self._canopy,
-            num_images = num_images,
-            annotation_type = self._options.annotation_type,
-            simulation_type = self._options.simulation_type,
-            labels = self._options.labels,
-            output_dir = output_dir)
-        
+            canopy=self._canopy,
+            num_images=num_images,
+            annotation_type=self._options.annotation_type,
+            simulation_type=self._options.simulation_type,
+            labels=self._options.labels,
+            output_dir=output_dir,
+        )
+
         # Recompile Helios with LiDAR capabilities if it is needed.
         if self._options.simulation_type == SimulationType.LiDAR:
             if not is_helios_compiled_with_lidar():
                 log("Recompiling Helios with LiDAR enabled.")
-                recompile_helios(lidar_enabled = True)
+                recompile_helios(lidar_enabled=True)
 
         # Create the output metadata directory.
-        metadata_dir = os.path.join(output_dir, '.metadata')
+        metadata_dir = os.path.join(output_dir, ".metadata")
         os.makedirs(metadata_dir)
 
         # Construct the XML parameter style file.
@@ -395,18 +411,21 @@ def generate(self, *,
         xml_options.write(os.path.join(metadata_dir, xml_file_base))
 
         # Write the actual configuration file.
-        cfg_file = os.path.join(PROJECT_PATH, f'config_{name}.txt')
+        cfg_file = os.path.join(PROJECT_PATH, f"config_{name}.txt")
+        self._write_config(cfg_file=cfg_file, xml_file=os.path.join(XML_PATH, xml_file_base))
         self._write_config(
-            cfg_file = cfg_file,
-            xml_file = os.path.join(XML_PATH, xml_file_base))
-        self._write_config(
-            cfg_file = os.path.join(metadata_dir, f'config_{name}.txt'),
-            xml_file = os.path.join(metadata_dir, xml_file_base))
+            cfg_file=os.path.join(metadata_dir, f"config_{name}.txt"),
+            xml_file=os.path.join(metadata_dir, xml_file_base),
+        )
 
         # Run the actual data generation with the executable.
-        process = sp.Popen([HELIOS_EXECUTABLE, cfg_file], stdout = sp.PIPE,
-                           stderr = sp.STDOUT, cwd = HELIOS_BUILD,
-                           universal_newlines = True,)
+        process = sp.Popen(
+            [HELIOS_EXECUTABLE, cfg_file],
+            stdout=sp.PIPE,
+            stderr=sp.STDOUT,
+            cwd=HELIOS_BUILD,
+            universal_newlines=True,
+        )
         for line in iter(process.stdout.readline, ""):
             sys.stdout.write(line)
         process.stdout.close()
@@ -417,22 +436,31 @@ def generate(self, *,
         os.remove(os.path.join(XML_PATH, xml_file_base))
 
         # Save the extra metadata.
-        with open(os.path.join(metadata_dir, 'meta.json'), 'w') as f:
-            json.dump({'labels': self._generation_options.labels,
-                       'image_size': self._options.camera.image_resolution,
-                       'generation_date': datetime.datetime.now().strftime(
-                           '%B %d, %Y %H:%M')}, f, indent = 4)
+        with open(os.path.join(metadata_dir, "meta.json"), "w") as f:
+            json.dump(
+                {
+                    "labels": self._generation_options.labels,
+                    "image_size": self._options.camera.image_resolution,
+                    "generation_date": datetime.datetime.now().strftime("%B %d, %Y %H:%M"),
+                },
+                f,
+                indent=4,
+            )
 
         # Check that the process successfully completed.
         if process.returncode != 0:
             if process.returncode == -11:
-                raise OSError(f"Encountered an error when generating synthetic "
-                              f"data. Process returned code {process.returncode}, "
-                              f"suggesting that the program ran out of memory. Try "
-                              f"passing a smaller environment for generation.")
+                raise OSError(
+                    f"Encountered an error when generating synthetic "
+                    f"data. Process returned code {process.returncode}, "
+                    f"suggesting that the program ran out of memory. Try "
+                    f"passing a smaller environment for generation."
+                )
             else:
-                raise OSError(f"Encountered an error when generating synthetic "
-                              f"data. Process returned code {process.returncode}.")
+                raise OSError(
+                    f"Encountered an error when generating synthetic "
+                    f"data. Process returned code {process.returncode}."
+                )
 
         # Convert the dataset format.
         if convert_data:
@@ -444,4 +472,3 @@ def generate(self, *,
                 return
             cvt = HeliosDataFormatConverter(output_dir)
             cvt.convert()
-
diff --git a/agml/synthetic/lidar_loader.py b/agml/synthetic/lidar_loader.py
index 6d0b537b..216c42f5 100644
--- a/agml/synthetic/lidar_loader.py
+++ b/agml/synthetic/lidar_loader.py
@@ -12,21 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import glob
 import os
 import re
-import glob
 
 import numpy as np
 
-from agml.framework import AgMLSerializable
 from agml.backend.config import synthetic_data_save_path
 from agml.data.point_cloud import PointCloud
+from agml.framework import AgMLSerializable
 from agml.utils.random import inject_random_state
 
 
 class LiDARDataLoader(AgMLSerializable):
     """A data loader for Helios-generated LiDAR point clouds."""
-    serializable = frozenset(('point_clouds', 'accessor_list'))
+
+    serializable = frozenset(("point_clouds", "accessor_list"))
 
     def __init__(self, location):
         # Parse the input location and load all of the point clouds.
@@ -56,15 +57,15 @@ def _setup_loader(self, location):
         else:
             location = os.path.join(synthetic_data_save_path(), location)
             if not os.path.isdir(location):
-                raise ValueError(f'Invalid location: {location}')
+                raise ValueError(f"Invalid location: {location}")
         structure = self._load_structure(location)
-        point_cloud_files = glob.glob(os.path.join(location, '**/*.xyz'), recursive = True)
-        self._point_clouds = [PointCloud(f, structure = structure) for f in point_cloud_files]
+        point_cloud_files = glob.glob(os.path.join(location, "**/*.xyz"), recursive=True)
+        self._point_clouds = [PointCloud(f, structure=structure) for f in point_cloud_files]
 
     @staticmethod
     def _load_structure(location):
         # Check if the metadata directory exists, and if the stylesheet exists.
-        style_query_path = os.path.join(location, '.metadata', 'style*.xml')
+        style_query_path = os.path.join(location, ".metadata", "style*.xml")
         if not os.path.exists(os.path.dirname(style_query_path)):
             return None
         style_file = glob.glob(style_query_path)
@@ -73,16 +74,15 @@ def _load_structure(location):
         style_file = style_file[0]
 
         # Load the `ASCII_format` XML tag if it exists.
-        contents = open(style_file, 'r').read()
-        ascii_format = re.search('<ASCII_format>(.*)</ASCII_format>', contents).group(1).strip()
-        ascii_format = ascii_format.replace('object_label', 'label')
-        ascii_format = ascii_format.split(' ')
+        contents = open(style_file, "r").read()
+        ascii_format = re.search("<ASCII_format>(.*)</ASCII_format>", contents).group(1).strip()
+        ascii_format = ascii_format.replace("object_label", "label")
+        ascii_format = ascii_format.split(" ")
         return ascii_format
 
-    def show_sample(self, format = 'default'):
+    def show_sample(self, format="default"):
         """Shows a sample of a point cloud in the loader."""
         # Prevent circular imports.
         from agml.viz.point_clouds import show_point_cloud
-        show_point_cloud(self._point_clouds[np.random.choice(self._accessor_list)], format = format)
-
 
+        show_point_cloud(self._point_clouds[np.random.choice(self._accessor_list)], format=format)
diff --git a/agml/synthetic/manual.py b/agml/synthetic/manual.py
index dc538003..0b30f48c 100644
--- a/agml/synthetic/manual.py
+++ b/agml/synthetic/manual.py
@@ -17,22 +17,25 @@
 import stat
 import sys
 import subprocess as sp
+import sys
 
 from agml.backend.config import SUPER_BASE_DIR
 from agml.synthetic.config import HELIOS_PATH
-from agml.utils.io import recursive_dirname, load_code_from_string_or_file
+from agml.utils.io import load_code_from_string_or_file, recursive_dirname
 from agml.utils.logging import log
 
 
-def generate_manual_data(code = None,
-                         cmake = None,
-                         xml = None,
-                         project_name = None,
-                         project_path = None,
-                         files_already_placed = False,
-                         overwrite_existing_files = False,
-                         force_recompile = False,
-                         cmake_build_type = 'Debug'):
+def generate_manual_data(
+    code=None,
+    cmake=None,
+    xml=None,
+    project_name=None,
+    project_path=None,
+    files_already_placed=False,
+    overwrite_existing_files=False,
+    force_recompile=False,
+    cmake_build_type="Debug",
+):
     """Manually generates data using Helios, given a generation script.
 
     This method can be used to generate data using Helios with more controls
@@ -77,12 +80,13 @@ def generate_manual_data(code = None,
     """
     if not files_already_placed:
         project_path, project_name, cmake = process_and_move_files(
-            code = code,
-            cmake = cmake,
-            xml = xml,
-            project_name = project_name,
-            project_path = project_path,
-            overwrite_existing_files = overwrite_existing_files)
+            code=code,
+            cmake=cmake,
+            xml=xml,
+            project_name=project_name,
+            project_path=project_path,
+            overwrite_existing_files=overwrite_existing_files,
+        )
     else:
         # Still run the project name/path check.
         if project_name is None and project_path is None:
@@ -91,7 +95,7 @@ def generate_manual_data(code = None,
             raise ValueError("Do not provide both the project name and path, just use one.")
 
         if project_name is not None and project_path is None:
-            project_path = os.path.join(HELIOS_PATH, 'projects', project_name)
+            project_path = os.path.join(HELIOS_PATH, "projects", project_name)
         if project_path is not None and project_name is None:
             project_name = os.path.basename(project_path)
             if not os.path.exists(project_path):
@@ -99,20 +103,20 @@ def generate_manual_data(code = None,
                     raise NotADirectoryError(
                         f"The parent Helios directory "
                         f"{recursive_dirname(project_path, 2)} "
-                        f"could not be found. Check that Helios is installed there.")
+                        f"could not be found. Check that Helios is installed there."
+                    )
 
         # Check that the necessary files exist.
         if not os.path.exists(os.path.join(project_path, 'main.cpp')) and not os.path.exists(os.path.join(project_path, 'generate.cpp')):
             raise ValueError(f"Could not find `main.cpp` file at {project_path}.")
-        if not os.path.exists(os.path.join(project_path, 'CMakeLists.txt')):
+        if not os.path.exists(os.path.join(project_path, "CMakeLists.txt")):
             raise ValueError(f"Could not find `CMakeLists.txt` file at {project_path}.")
 
     # Check whether Helios needs to be compiled (if any changes have been made).
     cpp_same, cmake_same = False, False
-    if os.path.exists(os.path.join(
-            SUPER_BASE_DIR, '.last_manual_compilation_cpp.cpp')) and not force_recompile:
+    if os.path.exists(os.path.join(SUPER_BASE_DIR, ".last_manual_compilation_cpp.cpp")) and not force_recompile:
         # Check if the C++ file has changed.
-        with open(os.path.join(SUPER_BASE_DIR, '.last_manual_compilation_cpp.cpp'), 'r') as f:
+        with open(os.path.join(SUPER_BASE_DIR, ".last_manual_compilation_cpp.cpp"), "r") as f:
             legacy_cpp = f.read()
         try:
             with open(os.path.join(project_path, 'main.cpp'), 'r') as f:
@@ -124,13 +128,13 @@ def generate_manual_data(code = None,
             cpp_same = True
 
         # Check if the CMake file has changed.
-        with open(os.path.join(SUPER_BASE_DIR, '.last_manual_compilation_cmake.txt'), 'r') as f:
+        with open(os.path.join(SUPER_BASE_DIR, ".last_manual_compilation_cmake.txt"), "r") as f:
             legacy_cmake = f.read()
-        with open(os.path.join(project_path, 'CMakeLists.txt'), 'r') as f:
+        with open(os.path.join(project_path, "CMakeLists.txt"), "r") as f:
             current_cmake = f.read()
         if legacy_cmake == current_cmake:
             cmake_same = True
-    
+
     # Compile Helios.
     if not cpp_same and not cmake_same:
         # Construct arguments for the compilation.
@@ -144,51 +148,63 @@ def generate_manual_data(code = None,
             os.unlink(log_file)
 
         # Create the build directory again, since it has been moved.
-        os.makedirs(helios_build, exist_ok = True)
+        os.makedirs(helios_build, exist_ok=True)
 
         # Compile the CMake files.
         cmake_log = ""
         sys.stderr.write("Compiling Helios with CMake.\n\n")
-        cmake_process = sp.Popen(cmake_args, stdout = sp.PIPE, cwd = helios_build,
-                                 stderr = sp.STDOUT, universal_newlines = True)
+        cmake_process = sp.Popen(
+            cmake_args,
+            stdout=sp.PIPE,
+            cwd=helios_build,
+            stderr=sp.STDOUT,
+            universal_newlines=True,
+        )
         for line in iter(cmake_process.stdout.readline, ""):
             cmake_log += line
             sys.stderr.write(line)
         cmake_process.stdout.close()
-        with open(log_file, 'a') as f:
+        with open(log_file, "a") as f:
             f.write(cmake_log)
         cmake_return = cmake_process.wait()
         if cmake_return != 0:
             raise ValueError(
-                f'\nEncountered an error when attempting to compile '
-                f'Helios with CMake. Please report this traceback to '
-                f'the AgML team. A full traceback of the compilation '
-                f'process can be found at "{log_file}".')
-        sys.stdout.write('\n')
-        sys.stderr.write('\n')
+                f"\nEncountered an error when attempting to compile "
+                f"Helios with CMake. Please report this traceback to "
+                f"the AgML team. A full traceback of the compilation "
+                f'process can be found at "{log_file}".'
+            )
+        sys.stdout.write("\n")
+        sys.stderr.write("\n")
 
         # Generate the main executable.
         cmake_log = "\n"
         sys.stderr.write("Building Helios executable with CMake.\n\n")
-        make_process = sp.Popen(make_args, stdout = sp.PIPE, cwd = helios_build,
-                                stderr = sp.STDOUT, universal_newlines = True)
+        make_process = sp.Popen(
+            make_args,
+            stdout=sp.PIPE,
+            cwd=helios_build,
+            stderr=sp.STDOUT,
+            universal_newlines=True,
+        )
         for line in iter(make_process.stdout.readline, ""):
             cmake_log += line
             sys.stderr.write(line)
         make_process.stdout.close()
-        with open(log_file, 'a') as f:
+        with open(log_file, "a") as f:
             f.write(cmake_log)
         make_return = make_process.wait()
         if make_return != 0:
             raise ValueError(
-                f'\nEncountered an error when attempting to compile '
-                f'Helios with CMake. Please report this traceback to '
-                f'the AgML team. A full traceback of the compilation '
-                f'process can be found at "{log_file}".')
+                f"\nEncountered an error when attempting to compile "
+                f"Helios with CMake. Please report this traceback to "
+                f"the AgML team. A full traceback of the compilation "
+                f'process can be found at "{log_file}".'
+            )
 
         # Print the final message.
-        sys.stdout.write('\n')
-        sys.stderr.write('\nHelios compilation successful!')
+        sys.stdout.write("\n")
+        sys.stderr.write("\nHelios compilation successful!")
 
     # Run the generation.
     executable = os.path.join(project_path, 'build', project_name)
@@ -218,29 +234,33 @@ def generate_manual_data(code = None,
             f.write(current_cmake)
 
 
-def process_and_move_files(code = None,
-                           cmake = None,
-                           xml = None,
-                           project_name = None,
-                           project_path = None,
-                           overwrite_existing_files = False):
+def process_and_move_files(
+    code=None,
+    cmake=None,
+    xml=None,
+    project_name=None,
+    project_path=None,
+    overwrite_existing_files=False,
+):
     """Processes and moves in files if provided in the manual generation method."""
     code = load_code_from_string_or_file(code)
 
     # Check if the code contains a reference to XML, and load the XML
     # stylesheet appropriately.
     xml_fname = None
-    if 'loadXML' in code:
+    if "loadXML" in code:
         if xml is None:
-            log('Detected a reference to `loadXML` in the provided C++ '
-                'generation file, but no XML stylesheet was provided for '
-                'manual generation. Generation may fail, unless the '
-                'stylesheet is already in the appropriate directory.')
+            log(
+                "Detected a reference to `loadXML` in the provided C++ "
+                "generation file, but no XML stylesheet was provided for "
+                "manual generation. Generation may fail, unless the "
+                "stylesheet is already in the appropriate directory."
+            )
         else:
             xml = load_code_from_string_or_file(xml)
 
             # Infer the name of the XML file.
-            fname = re.search('loadXML\\((.*?)\\)', xml).group(1)
+            fname = re.search("loadXML\\((.*?)\\)", xml).group(1)
             if '"' in fname:
                 fname = fname[1:-1]
             xml_fname = fname
@@ -252,49 +272,50 @@ def process_and_move_files(code = None,
         raise ValueError("Do not provide both the project name and path, just use one.")
 
     if project_name and not project_path:
-        project_path = os.path.join(HELIOS_PATH, 'projects', project_name)
+        project_path = os.path.join(HELIOS_PATH, "projects", project_name)
     if project_path and not project_name:
         if not os.path.exists(project_path):
             if not os.path.exists(recursive_dirname(project_path, 2)):
                 raise NotADirectoryError(
                     f"The parent Helios directory "
                     f"{recursive_dirname(project_path, 2)} "
-                    f"could not be found. Check that Helios is installed there.")
+                    f"could not be found. Check that Helios is installed there."
+                )
 
-    os.makedirs(project_path, exist_ok = True)
+    os.makedirs(project_path, exist_ok=True)
     if any(os.scandir(project_path)):
         if overwrite_existing_files:
             log(f"Existing files found at ({project_path}). Overwriting them.")
-            os.makedirs(project_path, exist_ok = True)
+            os.makedirs(project_path, exist_ok=True)
         else:
             raise ValueError(
                 f"Existing files found at ({project_path}). If you want to "
-                f"overwrite them, use the `overwrite_existing_files` argument.")
+                f"overwrite them, use the `overwrite_existing_files` argument."
+            )
 
     # Create the CMake file.
     if cmake is None:
-        cmake_default_path = os.path.join(
-            os.path.dirname(__file__),
-            'synthetic_data_generation', 'CMakeLists.txt')
-        with open(cmake_default_path, 'r') as f:
+        cmake_default_path = os.path.join(os.path.dirname(__file__), "synthetic_data_generation", "CMakeLists.txt")
+        with open(cmake_default_path, "r") as f:
             cmake_default = f.read()
-        if 'lidar' in code:
-            log("Detected a reference to LiDAR annotations in the provided"
+        if "lidar" in code:
+            log(
+                "Detected a reference to LiDAR annotations in the provided"
                 "C++ generation file. Since no CMake file has been provided,"
-                "the LiDAR plugin will be automatically used.")
+                "the LiDAR plugin will be automatically used."
+            )
             cmake_default = cmake_default.replace(
                 'set( PLUGINS "visualizer;canopygenerator;syntheticannotation" )',
-                'set( PLUGINS "visualizer;canopygenerator;syntheticannotation;lidar" )')
-        cmake = cmake_default.replace('generate.cpp', 'main.cpp').replace(
-            'SyntheticImageAnnotation', project_name
-        )
+                'set( PLUGINS "visualizer;canopygenerator;syntheticannotation;lidar" )',
+            )
+        cmake = cmake_default.replace("generate.cpp", "main.cpp").replace("SyntheticImageAnnotation", project_name)
     else:
         cmake = load_code_from_string_or_file(cmake)
 
     # Move in the necessary files.
-    with open(os.path.join(project_path, 'main.cpp'), 'w') as f:
+    with open(os.path.join(project_path, "main.cpp"), "w") as f:
         f.write(code)
-    with open(os.path.join(project_path, 'CMakeLists.txt'), 'w') as f:
+    with open(os.path.join(project_path, "CMakeLists.txt"), "w") as f:
         f.write(cmake)
     if xml is not None:
         with open(os.path.join(project_path, xml_fname)) as f:
@@ -302,5 +323,3 @@ def process_and_move_files(code = None,
 
     # Return the project name and path.
     return project_path, project_name, cmake
-
-
diff --git a/agml/synthetic/options.py b/agml/synthetic/options.py
index 0c092d2b..5e4f7742 100644
--- a/agml/synthetic/options.py
+++ b/agml/synthetic/options.py
@@ -13,10 +13,10 @@
 # limitations under the License.
 
 import os
+from dataclasses import asdict, dataclass, fields
 from enum import Enum
 from numbers import Number
-from dataclasses import dataclass, fields, asdict
-from typing import List, Union, Sequence, TypeVar, Any
+from typing import Any, List, Sequence, TypeVar, Union
 
 from agml.framework import AgMLSerializable
 from agml.synthetic.config import load_default_helios_configuration, verify_helios
@@ -25,6 +25,7 @@
 
 class AnnotationType(Enum):
     """The type of annotation to use in generation."""
+
     object_detection: str = "object_detection"
     semantic_segmentation: str = "semantic_segmentation"
     instance_segmentation: str = "instance_segmentation"
@@ -33,15 +34,16 @@ class AnnotationType(Enum):
 
 class SimulationType(Enum):
     """The simulation render (RGB vs. LiDAR) that is generated."""
+
     RGB: str = "rgb"
     LiDAR: str = "lidar"
     Both: str = "rgb lidar"
 
 
-NumberOrMaybeList = TypeVar('NumberOrMaybeList', Number, List[Number])
+NumberOrMaybeList = TypeVar("NumberOrMaybeList", Number, List[Number])
 
 
-@dataclass(repr = False)
+@dataclass(repr=False)
 class Parameters:
     """Base class for parameters, to enable runtime type checks."""
 
@@ -56,21 +58,17 @@ def __post_init__(self):
 
     def __repr__(self):
         # This is custom-defined to exclude optional unused attributes.
-        defined_values = (
-            (f.name, getattr(self, f.name))
-            for f in fields(self)
-            if getattr(self, f.name) != f.default)
+        defined_values = ((f.name, getattr(self, f.name)) for f in fields(self) if getattr(self, f.name) != f.default)
         value_repr = ", ".join(f"{name}={value}" for name, value in defined_values)
         return f"{self.__class__.__qualname__}({value_repr})"
 
     def __setattr__(self, key, value):
         # Don't allow the assignment of new attributes.
         if key not in self.__dict__.keys():
-            if not hasattr(self, '_block_new_attributes'):
+            if not hasattr(self, "_block_new_attributes"):
                 super().__setattr__(key, value)
                 return
-            raise AttributeError(f"Cannot assign new attributes '{key}' "
-                                 f"to class {self.__class__.__name__}.")
+            raise AttributeError(f"Cannot assign new attributes '{key}' " f"to class {self.__class__.__name__}.")
 
         # Check if the type of the value matches that of the key.
         annotation = self.__annotations__[key]
@@ -86,12 +84,13 @@ def __setattr__(self, key, value):
             if not isinstance(value, annotation):
                 raise TypeError(
                     f"Expected a value of type ({annotation}) for attribute "
-                    f"'{key}', instead got '{value}' of type ({type(value)}).")
+                    f"'{key}', instead got '{value}' of type ({type(value)})."
+                )
 
         super().__setattr__(key, value)
 
 
-@dataclass(repr = False)
+@dataclass(repr=False)
 class CanopyParameters(Parameters):
     """Stores canopy-specific parameters for Helios.
 
@@ -100,167 +99,176 @@ class CanopyParameters(Parameters):
     may only use a fraction of these specific canopies. This is to ensure that
     different canopy parameters auto-complete when actually writing code.
     """
-    leaf_length: Number                   = None
-    leaf_width: Number                    = None
-    leaf_size: Number                     = None
-    leaf_subdivisions: List[Number]       = None
-    leaf_texture_file: str                = None
-    leaf_color: str                       = None
-    leaf_angle_distribution: str          = None
-    leaf_area_index: Number               = None
-    leaf_area_density: Number             = None
-    leaf_spacing_fraction: Number         = None
-    leaflet_length: Number                = None
-    stem_color: List[Number]              = None
-    stem_subdivisions: Number             = None
-    stems_per_plant: Number               = None
-    stem_radius: Number                   = None
-    stem_length: Number                   = None
-    plant_height: Number                  = None
-    grape_radius: Number                  = None
-    grape_color: List[Number]             = None
-    grape_subdivisions: Number            = None
-    fruit_color: List[Number]             = None
-    fruit_radius: Number                  = None
-    fruit_subdivisions: Number            = None
-    fruit_texture_file: os.PathLike       = None
-    wood_texture_file: os.PathLike        = None
-    wood_subdivisions: Number             = None
-    clusters_per_stem: Number             = None
-    plant_spacing: Number                 = None
-    row_spacing: Number                   = None
-    level_spacing: Number                 = None
-    plant_count: List[Number]             = None
-    canopy_origin: List[Number]           = None
-    canopy_rotation: Number               = None
-    canopy_height: Number                 = None
-    canopy_extent: List[Number]           = None
-    canopy_configuration: str             = None
-    base_height: Number                   = None
-    crown_radius: Number                  = None
-    cluster_radius: Number                = None
-    cluster_height_max: Number            = None
-    trunk_height: Number                  = None
-    trunk_radius: Number                  = None
-    cordon_height: Number                 = None
-    cordon_radius: Number                 = None
-    cordon_spacing: Number                = None
-    shoot_length: Number                  = None
-    shoot_radius: Number                  = None
-    shoots_per_cordon: Number             = None
-    shoot_angle: Number                   = None
-    shoot_angle_tip: Number               = None
-    shoot_angle_base: Number              = None
-    shoot_color: List[Number]             = None
+
+    leaf_length: Number = None
+    leaf_width: Number = None
+    leaf_size: Number = None
+    leaf_subdivisions: List[Number] = None
+    leaf_texture_file: str = None
+    leaf_color: str = None
+    leaf_angle_distribution: str = None
+    leaf_area_index: Number = None
+    leaf_area_density: Number = None
+    leaf_spacing_fraction: Number = None
+    leaflet_length: Number = None
+    stem_color: List[Number] = None
+    stem_subdivisions: Number = None
+    stems_per_plant: Number = None
+    stem_radius: Number = None
+    stem_length: Number = None
+    plant_height: Number = None
+    grape_radius: Number = None
+    grape_color: List[Number] = None
+    grape_subdivisions: Number = None
+    fruit_color: List[Number] = None
+    fruit_radius: Number = None
+    fruit_subdivisions: Number = None
+    fruit_texture_file: os.PathLike = None
+    wood_texture_file: os.PathLike = None
+    wood_subdivisions: Number = None
+    clusters_per_stem: Number = None
+    plant_spacing: Number = None
+    row_spacing: Number = None
+    level_spacing: Number = None
+    plant_count: List[Number] = None
+    canopy_origin: List[Number] = None
+    canopy_rotation: Number = None
+    canopy_height: Number = None
+    canopy_extent: List[Number] = None
+    canopy_configuration: str = None
+    base_height: Number = None
+    crown_radius: Number = None
+    cluster_radius: Number = None
+    cluster_height_max: Number = None
+    trunk_height: Number = None
+    trunk_radius: Number = None
+    cordon_height: Number = None
+    cordon_radius: Number = None
+    cordon_spacing: Number = None
+    shoot_length: Number = None
+    shoot_radius: Number = None
+    shoots_per_cordon: Number = None
+    shoot_angle: Number = None
+    shoot_angle_tip: Number = None
+    shoot_angle_base: Number = None
+    shoot_color: List[Number] = None
     shoot_subdivisions: NumberOrMaybeList = None
-    pod_color: List[Number]               = None
-    pod_subdivisions: NumberOrMaybeList   = None
-    pod_length: None                      = None
-    germination_probability: Number       = None
-    needle_width: Number                  = None
-    needle_length: Number                 = None
-    needle_color: List[Number]            = None
-    needle_subdivisions: List[Number]     = None
-    branch_length: Number                 = None
-    branches_per_level: Number            = None
-    buffer: str                           = None
+    pod_color: List[Number] = None
+    pod_subdivisions: NumberOrMaybeList = None
+    pod_length: None = None
+    germination_probability: Number = None
+    needle_width: Number = None
+    needle_length: Number = None
+    needle_color: List[Number] = None
+    needle_subdivisions: List[Number] = None
+    branch_length: Number = None
+    branches_per_level: Number = None
+    buffer: str = None
 
     # sorghum options
-    sorghum_stage: Number                 = None
-    s1_stem_length: Number                = None
-    s1_stem_radius: Number                = None
-    s1_stem_subdivisions: Number          = None
-    s1_leaf_size1: List[Number]           = None
-    s1_leaf_size2: List[Number]           = None
-    s1_leaf_size3: List[Number]           = None
-    s1_leaf1_angle: Number                = None
-    s1_leaf2_angle: Number                = None
-    s1_leaf3_angle: Number                = None
-    s1_leaf_subdivisions: List[Number]    = None
-    s1_leaf_texture_file: str             = None
-    s2_stem_length: Number                = None
-    s2_stem_radius: Number                = None
-    s2_stem_subdivisions: Number          = None
-    s2_leaf_size1: List[Number]           = None
-    s2_leaf_size2: List[Number]           = None
-    s2_leaf_size3: List[Number]           = None
-    s2_leaf_size4: List[Number]           = None
-    s2_leaf_size5: List[Number]           = None
-    s2_leaf1_angle: Number                = None
-    s2_leaf2_angle: Number                = None
-    s2_leaf3_angle: Number                = None
-    s2_leaf4_angle: Number                = None
-    s2_leaf5_angle: Number                = None
-    s2_leaf_subdivisions: List[Number]    = None
-    s2_leaf_texture_file: str             = None
-    s3_stem_length: Number                = None
-    s3_stem_radius: Number                = None
-    s3_stem_subdivisions: Number          = None
-    s3_leaf_size: List[Number]            = None
-    s3_leaf_subdivisions: List[Number]    = None
-    s3_number_of_leaves: Number           = None
-    s3_mean_leaf_angle: Number            = None
-    s3_leaf_texture_file: str             = None
-    s4_stem_length: Number                = None
-    s4_stem_radius: Number                = None
-    s4_stem_subdivisions: Number          = None
-    s4_panicle_size: List[Number]         = None
-    s4_panicle_subdivisions: Number       = None
-    s4_seed_texture_file: str             = None
-    s4_leaf_size: List[Number]            = None
-    s4_leaf_subdivisions: List[Number]    = None
-    s4_number_of_leaves: Number           = None
-    s4_mean_leaf_angle: Number            = None
-    s4_leaf_texture_file: str             = None
-    s5_stem_length: Number                = None
-    s5_stem_radius: Number                = None
-    s5_stem_bend: Number                  = None
-    s5_stem_subdivisions: Number          = None
-    s5_panicle_size: List[Number]         = None
-    s5_panicle_subdivisions: Number       = None
-    s5_seed_texture_file: str             = None
-    s5_leaf_size: List[Number]            = None
-    s5_leaf_subdivisions: List[Number]    = None
-    s5_number_of_leaves: Number           = None
-    s5_mean_leaf_angle: Number            = None
-    s5_leaf_texture_file: str             = None
-
-
-@dataclass(repr = False)
+    sorghum_stage: Number = None
+    s1_stem_length: Number = None
+    s1_stem_radius: Number = None
+    s1_stem_subdivisions: Number = None
+    s1_leaf_size1: List[Number] = None
+    s1_leaf_size2: List[Number] = None
+    s1_leaf_size3: List[Number] = None
+    s1_leaf1_angle: Number = None
+    s1_leaf2_angle: Number = None
+    s1_leaf3_angle: Number = None
+    s1_leaf_subdivisions: List[Number] = None
+    s1_leaf_texture_file: str = None
+    s2_stem_length: Number = None
+    s2_stem_radius: Number = None
+    s2_stem_subdivisions: Number = None
+    s2_leaf_size1: List[Number] = None
+    s2_leaf_size2: List[Number] = None
+    s2_leaf_size3: List[Number] = None
+    s2_leaf_size4: List[Number] = None
+    s2_leaf_size5: List[Number] = None
+    s2_leaf1_angle: Number = None
+    s2_leaf2_angle: Number = None
+    s2_leaf3_angle: Number = None
+    s2_leaf4_angle: Number = None
+    s2_leaf5_angle: Number = None
+    s2_leaf_subdivisions: List[Number] = None
+    s2_leaf_texture_file: str = None
+    s3_stem_length: Number = None
+    s3_stem_radius: Number = None
+    s3_stem_subdivisions: Number = None
+    s3_leaf_size: List[Number] = None
+    s3_leaf_subdivisions: List[Number] = None
+    s3_number_of_leaves: Number = None
+    s3_mean_leaf_angle: Number = None
+    s3_leaf_texture_file: str = None
+    s4_stem_length: Number = None
+    s4_stem_radius: Number = None
+    s4_stem_subdivisions: Number = None
+    s4_panicle_size: List[Number] = None
+    s4_panicle_subdivisions: Number = None
+    s4_seed_texture_file: str = None
+    s4_leaf_size: List[Number] = None
+    s4_leaf_subdivisions: List[Number] = None
+    s4_number_of_leaves: Number = None
+    s4_mean_leaf_angle: Number = None
+    s4_leaf_texture_file: str = None
+    s5_stem_length: Number = None
+    s5_stem_radius: Number = None
+    s5_stem_bend: Number = None
+    s5_stem_subdivisions: Number = None
+    s5_panicle_size: List[Number] = None
+    s5_panicle_subdivisions: Number = None
+    s5_seed_texture_file: str = None
+    s5_leaf_size: List[Number] = None
+    s5_leaf_subdivisions: List[Number] = None
+    s5_number_of_leaves: Number = None
+    s5_mean_leaf_angle: Number = None
+    s5_leaf_texture_file: str = None
+
+
+@dataclass(repr=False)
 class CameraParameters(Parameters):
     """Stores camera parameters for Helios."""
-    image_resolution: List[Number]  = None
-    camera_position: List[Number]   = None
-    camera_lookat: List[Number]     = None
-
-    def generate_positions(self,
-                           camera_type: str,
-                           num_views: int,
-                           origin: List[Union[int, float]] = None,
-                           camera_spacing: int = 2,
-                           crop_distance: Union[int, float] = 4,
-                           height: int = 1,
-                           aerial_parameters: dict = {}):
+
+    image_resolution: List[Number] = None
+    camera_position: List[Number] = None
+    camera_lookat: List[Number] = None
+
+    def generate_positions(
+        self,
+        camera_type: str,
+        num_views: int,
+        origin: List[Union[int, float]] = None,
+        camera_spacing: int = 2,
+        crop_distance: Union[int, float] = 4,
+        height: int = 1,
+        aerial_parameters: dict = {},
+    ):
         """Generates camera positions from the input environment parameters."""
         self.camera_position, self.camera_lookat = generate_camera_positions(
-            camera_type = camera_type, num_views = num_views,
-            origin = origin, camera_spacing = camera_spacing,
-            crop_distance = crop_distance, height = height,
-            aerial_parameters = aerial_parameters)
+            camera_type=camera_type,
+            num_views=num_views,
+            origin=origin,
+            camera_spacing=camera_spacing,
+            crop_distance=crop_distance,
+            height=height,
+            aerial_parameters=aerial_parameters,
+        )
 
 
-@dataclass(repr = False)
+@dataclass(repr=False)
 class LiDARParameters(Parameters):
     """Stores LiDAR parameters for Helios."""
-    origin: Any                 = None # can be a list of lists or a list of numbers
-    size: List[int]             = None
-    thetaMin: Number            = None
-    thetaMax: Number            = None
-    phiMin: Number              = None
-    phiMax: Number              = None
-    exitDiameter: Number        = None
-    beamDivergence: Number      = None
-    ASCII_format: str           = None
+
+    origin: Any = None  # can be a list of lists or a list of numbers
+    size: List[int] = None
+    thetaMin: Number = None
+    thetaMax: Number = None
+    phiMin: Number = None
+    phiMax: Number = None
+    exitDiameter: Number = None
+    beamDivergence: Number = None
+    ASCII_format: str = None
 
 
 class HeliosOptions(AgMLSerializable):
@@ -285,9 +293,18 @@ class HeliosOptions(AgMLSerializable):
     canopy : str
         The type of plant canopy to be used in generation.
     """
-    serializable = frozenset(('canopy', 'canopy_parameters',
-                              'camera_parameters', 'lidar_parameters',
-                              'annotation_type', 'simulation_type', 'labels'))
+
+    serializable = frozenset(
+        (
+            "canopy",
+            "canopy_parameters",
+            "camera_parameters",
+            "lidar_parameters",
+            "annotation_type",
+            "simulation_type",
+            "labels",
+        )
+    )
 
     @verify_helios
     def __new__(cls, *args, **kwargs):
@@ -297,33 +314,31 @@ def __new__(cls, *args, **kwargs):
         cls._default_config = load_default_helios_configuration()
         return super(HeliosOptions, cls).__new__(cls)
 
-    def __init__(self, canopy = None):
+    def __init__(self, canopy=None):
         # Check that the provided canopy is valid.
         self._initialize_canopy(canopy)
 
         # Initialize the default data generation parameters.
         self._annotation_type = AnnotationType.object_detection
         self._simulation_type = SimulationType.RGB
-        self._labels = ['leaves']
+        self._labels = ["leaves"]
 
     def __str__(self):
         return f"HeliosOptions({self._canopy})({self._to_dict()})"
 
     def _initialize_canopy(self, canopy):
         """Initializes Helios options from the provided canopy."""
-        if canopy not in self._default_config['canopy']['types']:
+        if canopy not in self._default_config["canopy"]["types"]:
             raise ValueError(
                 f"Received invalid canopy type '{canopy}', expected "
-                f"one of: {self._default_config['canopy']['types']}.")
+                f"one of: {self._default_config['canopy']['types']}."
+            )
         self._canopy = canopy
 
         # Get the parameters and ranges corresponding to the canopy type.
-        self._canopy_parameters = \
-            CanopyParameters(**self._default_config['canopy']['parameters'][canopy])
-        self._camera_parameters = \
-            CameraParameters(**self._default_config['camera']['parameters'])
-        self._lidar_parameters = \
-            LiDARParameters(**self._default_config['lidar']['parameters'])
+        self._canopy_parameters = CanopyParameters(**self._default_config["canopy"]["parameters"][canopy])
+        self._camera_parameters = CameraParameters(**self._default_config["camera"]["parameters"])
+        self._lidar_parameters = LiDARParameters(**self._default_config["lidar"]["parameters"])
 
     @property
     def canopy(self) -> CanopyParameters:
@@ -336,7 +351,7 @@ def camera(self) -> CameraParameters:
     @property
     def lidar(self) -> LiDARParameters:
         return self._lidar_parameters
-    
+
     @property
     def annotation_type(self) -> List:
         # The returned annotation type needs to be a list. If there is only
@@ -344,7 +359,7 @@ def annotation_type(self) -> List:
         # that it is passed in a list format to the Helios data generator.
         at = self._annotation_type
         return at if isinstance(at, list) else [at]
-    
+
     @annotation_type.setter
     def annotation_type(self, value: Union[AnnotationType, str, List[Union[AnnotationType, str]]]):
         if isinstance(value, list):
@@ -364,10 +379,10 @@ def simulation_type(self, value: Union[SimulationType, str]):
         if self._simulation_type == SimulationType.LiDAR:
             try:
                 import subprocess as sp
-                sp.check_call('nvidia-smi', stdout = sp.DEVNULL)
+
+                sp.check_call("nvidia-smi", stdout=sp.DEVNULL)
             except Exception:
-                raise RuntimeError(
-                    "You must have a CUDA-capable GPU to run LiDAR simulations.")
+                raise RuntimeError("You must have a CUDA-capable GPU to run LiDAR simulations.")
 
     @property
     def labels(self) -> list:
@@ -376,8 +391,9 @@ def labels(self) -> list:
     @labels.setter
     def labels(self, value: Sequence):
         if len(value) == 0:
-            raise ValueError("You cannot have no labels, choose a combination "
-                             "of `trunks`, `fruits`, `branches`, and `leaves`.")
+            raise ValueError(
+                "You cannot have no labels, choose a combination " "of `trunks`, `fruits`, `branches`, and `leaves`."
+            )
         self._labels = value
 
     def reset(self):
@@ -391,9 +407,7 @@ def _asdict(obj):
     def _to_dict(self):
         """Returns the options in dictionary format."""
         return {
-            'canopy': self._asdict(self._canopy_parameters),
-            'camera': self._asdict(self._camera_parameters),
-            'lidar': self._asdict(self._lidar_parameters)
+            "canopy": self._asdict(self._canopy_parameters),
+            "camera": self._asdict(self._camera_parameters),
+            "lidar": self._asdict(self._lidar_parameters),
         }
-
-
diff --git a/agml/synthetic/tools.py b/agml/synthetic/tools.py
index a772d326..09cf5027 100644
--- a/agml/synthetic/tools.py
+++ b/agml/synthetic/tools.py
@@ -14,10 +14,9 @@
 
 """Tools for working with synthetic data in the Helios format."""
 
-import os
-
 import math
-from typing import List, Union, Tuple
+import os
+from typing import List, Tuple, Union
 
 import numpy as np
 from scipy.signal import sawtooth
@@ -26,12 +25,13 @@
 
 
 def generate_environment_map(
-        origin: List[Union[int, float]],
-        plant_spacing: int = 1,
-        row_spacing: int = 4,
-        trees_per_row: int = 1,
-        rows: int = 1,
-        plant_height: int = 1) -> list:
+    origin: List[Union[int, float]],
+    plant_spacing: int = 1,
+    row_spacing: int = 4,
+    trees_per_row: int = 1,
+    rows: int = 1,
+    plant_height: int = 1,
+) -> list:
     """Generates an environment map in the Helios format.
 
     This method returns a list of NumPy arrays which contain coordinates
@@ -61,47 +61,73 @@ def generate_environment_map(
     # If there is only one row and only one tree in the row, then there
     # is only one plant whose coordinates needs to be generated.
     if trees_per_row == 1 and rows == 1:
-        return [[np.concatenate([np.array([origin[0]]), np.array([origin[1]]),
-                                 plant_height / 2 + np.array([origin[2]])])]]
+        return [
+            [
+                np.concatenate(
+                    [
+                        np.array([origin[0]]),
+                        np.array([origin[1]]),
+                        plant_height / 2 + np.array([origin[2]]),
+                    ]
+                )
+            ]
+        ]
 
     # Calculate the x- positions for the trees.
     if trees_per_row % 2 != 0 and trees_per_row > 1:  # odd number
         x_pos = np.concatenate(
-            [np.array([origin[0]]), np.linspace(
-                origin[0] + plant_spacing, trees_per_row / 2 * plant_spacing -
-                plant_spacing / 2, int(trees_per_row / 2))])
+            [
+                np.array([origin[0]]),
+                np.linspace(
+                    origin[0] + plant_spacing,
+                    trees_per_row / 2 * plant_spacing - plant_spacing / 2,
+                    int(trees_per_row / 2),
+                ),
+            ]
+        )
         x_pos = np.concatenate([np.sort(-x_pos[1:]), x_pos])
     else:  # even number
-        x_pos = np.linspace(origin[0] + (plant_spacing / 2),
-                            trees_per_row / 2 * plant_spacing - plant_spacing / 2,
-                            int(trees_per_row / 2))
+        x_pos = np.linspace(
+            origin[0] + (plant_spacing / 2),
+            trees_per_row / 2 * plant_spacing - plant_spacing / 2,
+            int(trees_per_row / 2),
+        )
         x_pos = np.concatenate([np.sort(-x_pos[:]), x_pos])
 
     # Calculate the y- positions for the trees.
     if rows % 2 != 0:  # odd number
         y_pos = np.concatenate(
-            [np.array([origin[0]]), np.linspace(
-                origin[1] + row_spacing, rows / 2 * row_spacing -
-                row_spacing / 2, int(rows / 2))])
+            [
+                np.array([origin[0]]),
+                np.linspace(
+                    origin[1] + row_spacing,
+                    rows / 2 * row_spacing - row_spacing / 2,
+                    int(rows / 2),
+                ),
+            ]
+        )
         y_pos = np.concatenate([np.sort(-y_pos[1:]), y_pos])
     else:
-        y_pos = np.linspace(origin[1] + (row_spacing / 2),
-                            rows / 2 * row_spacing - row_spacing / 2, int(rows / 2))
+        y_pos = np.linspace(
+            origin[1] + (row_spacing / 2),
+            rows / 2 * row_spacing - row_spacing / 2,
+            int(rows / 2),
+        )
         y_pos = np.concatenate([np.sort(-y_pos[:]), y_pos])
 
     # Return the x- and y- positions.
-    return [[[x_pos[x], y_pos[y], plant_height / 2 + origin[2]]
-             for x in range(len(x_pos))] for y in range(len(y_pos))]
+    return [[[x_pos[x], y_pos[y], plant_height / 2 + origin[2]] for x in range(len(x_pos))] for y in range(len(y_pos))]
 
 
 def generate_camera_positions(
-        camera_type: str,
-        num_views: int,
-        origin: List[Union[int, float]] = None,
-        camera_spacing: int = 2,
-        crop_distance: int = 4,
-        height: int = 1,
-        aerial_parameters: dict = {}) -> Tuple:
+    camera_type: str,
+    num_views: int,
+    origin: List[Union[int, float]] = None,
+    camera_spacing: int = 2,
+    crop_distance: int = 4,
+    height: int = 1,
+    aerial_parameters: dict = {},
+) -> Tuple:
     """Generates camera placement and lookat positions in the Helios format.
     This method, given the origin and a number of camera positions to generate
     (as specified in `num_views`), returns the 3-d coordinates of the camera
@@ -137,53 +163,69 @@ def generate_camera_positions(
     if origin is None:
         origin = [0, 0, 0]
 
-    if camera_type == 'circular':
-        return [[math.cos(2 * math.pi / num_views * x) * crop_distance, 
-                  math.sin(2 * math.pi / num_views * x) * crop_distance, height] 
-                 for x in range(0, num_views)], [[0, 0, 1] for _ in range(0, num_views)]
-
-    elif camera_type == 'linear':
-        camera_pos = np.arange(
-            origin[0], camera_spacing * num_views + origin[0], camera_spacing)
-        return [[camera_pos[x], crop_distance + origin[1], height]
-                for x in range(len(camera_pos))], \
-                [[camera_pos[x], origin[0], height] for x in range(len(camera_pos))]
-
-    elif camera_type == 'aerial':
-        if aerial_parameters.get('distribution', '') == 'sawtooth':
-            angled = aerial_parameters.get('angled', False)
+    if camera_type == "circular":
+        return [
+            [
+                math.cos(2 * math.pi / num_views * x) * crop_distance,
+                math.sin(2 * math.pi / num_views * x) * crop_distance,
+                height,
+            ]
+            for x in range(0, num_views)
+        ], [[0, 0, 1] for _ in range(0, num_views)]
+
+    elif camera_type == "linear":
+        camera_pos = np.arange(origin[0], camera_spacing * num_views + origin[0], camera_spacing)
+        return [[camera_pos[x], crop_distance + origin[1], height] for x in range(len(camera_pos))], [
+            [camera_pos[x], origin[0], height] for x in range(len(camera_pos))
+        ]
+
+    elif camera_type == "aerial":
+        if aerial_parameters.get("distribution", "") == "sawtooth":
+            angled = aerial_parameters.get("angled", False)
             t = camera_spacing * np.linspace(0, 1, num_views)
             triangle = camera_spacing * sawtooth(1 * np.pi * 5 * t, 0.5)
-            return [[t[x] + origin[0], triangle[x] + origin[1],
-                      crop_distance + origin[2]] for x in range(len(triangle))], \
-                    [[t[x] + origin[0], triangle[x] + origin[1] + (1 if angled else 0.05),
-                      height + origin[2]] for x in range(len(triangle))]
-        else: # distribution is circular around the center
-            angled = aerial_parameters.get('angled', False)
+            return [
+                [t[x] + origin[0], triangle[x] + origin[1], crop_distance + origin[2]] for x in range(len(triangle))
+            ], [
+                [
+                    t[x] + origin[0],
+                    triangle[x] + origin[1] + (1 if angled else 0.05),
+                    height + origin[2],
+                ]
+                for x in range(len(triangle))
+            ]
+        else:  # distribution is circular around the center
+            angled = aerial_parameters.get("angled", False)
             center_coord = [[origin[0], origin[1]]]
             if num_views == 1:
                 coords = center_coord
             elif num_views == 2:
                 coords = [center_coord[0], [origin[0], origin[1] + 0.5]]
             elif num_views == 3:
-                coords = [center_coord[0], [origin[0], origin[1] - 0.5],
-                          [origin[0], origin[1] + 0.5]]
+                coords = [
+                    center_coord[0],
+                    [origin[0], origin[1] - 0.5],
+                    [origin[0], origin[1] + 0.5],
+                ]
             else:
                 coords = center_coord
                 coords.extend(
-                    [[origin[0] + np.cos(theta), origin[1] + np.sin(theta)]
-                     for theta in np.linspace(0, 2 * np.pi, num_views)])
+                    [
+                        [origin[0] + np.cos(theta), origin[1] + np.sin(theta)]
+                        for theta in np.linspace(0, 2 * np.pi, num_views)
+                    ]
+                )
 
-            return [[*coord, crop_distance + origin[2]] for coord in coords], \
-                   [[coord[0], coord[1] + (1 if angled else 0.05),
-                     height + origin[2]] for coord in coords]
+            return [[*coord, crop_distance + origin[2]] for coord in coords], [
+                [coord[0], coord[1] + (1 if angled else 0.05), height + origin[2]] for coord in coords
+            ]
 
     else:
-        raise ValueError(f"Got `camera_type`: ({camera_type}), "
-                         f"expected either `circular`, `linear`, or `aerial`.")
+        raise ValueError(f"Got `camera_type`: ({camera_type}), " f"expected either `circular`, `linear`, or `aerial`.")
 
 
 def _is_agml_converted(dataset_path):
     """Returns whether a Helios dataset has been converted to AgML format."""
-    return os.path.exists(os.path.join(dataset_path, '.metadata', 'agml_info.json')) \
-            or get_dir_list(dataset_path) == ['.metadata'] # dataset with no annotations
+    return os.path.exists(os.path.join(dataset_path, ".metadata", "agml_info.json")) or get_dir_list(dataset_path) == [
+        ".metadata"
+    ]  # dataset with no annotations
diff --git a/agml/utils/data.py b/agml/utils/data.py
index a3fb57cd..22be1583 100644
--- a/agml/utils/data.py
+++ b/agml/utils/data.py
@@ -12,68 +12,69 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
-import sys
-import json
-import shutil
 import difflib
 import functools
+import json
+import os
+import shutil
+import sys
 
 
-@functools.lru_cache(maxsize = None)
+@functools.lru_cache(maxsize=None)
 def load_public_sources() -> dict:
     """Loads the public data sources JSON file."""
-    with open(os.path.join(
+    with open(
+        os.path.join(
             os.path.dirname(os.path.dirname(__file__)),
-            '_assets/public_datasources.json')) as f:
+            "_assets/public_datasources.json",
+        )
+    ) as f:
         return json.load(f)
 
 
-@functools.lru_cache(maxsize = None)
+@functools.lru_cache(maxsize=None)
 def load_citation_sources() -> dict:
     """Loads the citation sources JSON file."""
-    with open(os.path.join(
-            os.path.dirname(os.path.dirname(__file__)),
-            '_assets/source_citations.json')) as f:
+    with open(os.path.join(os.path.dirname(os.path.dirname(__file__)), "_assets/source_citations.json")) as f:
         return json.load(f)
 
 
-@functools.lru_cache(maxsize = None)
+@functools.lru_cache(maxsize=None)
 def load_model_benchmarks() -> dict:
     """Loads the citation sources JSON file."""
-    with open(os.path.join(
-            os.path.dirname(os.path.dirname(__file__)),
-            '_assets/model_benchmarks.json')) as f:
+    with open(os.path.join(os.path.dirname(os.path.dirname(__file__)), "_assets/model_benchmarks.json")) as f:
         return json.load(f)
 
 
-@functools.lru_cache(maxsize = None)
+@functools.lru_cache(maxsize=None)
 def load_detector_benchmarks() -> dict:
     """Loads the citation sources JSON file."""
-    with open(os.path.join(
+    with open(
+        os.path.join(
             os.path.dirname(os.path.dirname(__file__)),
-            '_assets/detector_benchmarks.json')) as f:
+            "_assets/detector_benchmarks.json",
+        )
+    ) as f:
         return json.load(f)
 
 
-def maybe_you_meant(name, msg, source = None) -> str:
+def maybe_you_meant(name, msg, source=None) -> str:
     """Suggests potential correct spellings for an invalid name."""
-    source = source if source is not None \
-                    else load_public_sources().keys()
+    source = source if source is not None else load_public_sources().keys()
     suggestion = difflib.get_close_matches(name, source)
     if len(suggestion) == 0:
         return msg
     return msg + f" Maybe you meant: '{suggestion[0]}'?"
 
 
-def copyright_print(name, location = None):
+def copyright_print(name, location=None):
     """Prints out license/copyright info after a dataset download."""
     content = load_citation_sources()[name]
-    license = content['license'] # noqa
-    citation = content['citation']
+    license = content["license"]  # noqa
+    citation = content["citation"]
 
-    def _bold(msg): # noqa
-        return '\033[1m' + msg + '\033[0m'
+    def _bold(msg):  # noqa
+        return "\033[1m" + msg + "\033[0m"
 
     if location is None:
         first_msg = "Citation information for " + _bold(name) + ".\n"
@@ -81,55 +82,53 @@ def _bold(msg): # noqa
         first_msg = "You have just downloaded " + _bold(name) + ".\n"
 
     _LICENSE_TO_URL = {
-        'CC BY-SA 4.0': 'https://creativecommons.org/licenses/by-sa/4.0/',
-        'CC BY-SA 3.0': 'https://creativecommons.org/licenses/by-sa/3.0/',
-        'CC BY-NC 3.0': 'https://creativecommons.org/licenses/by-nc/3.0/',
-        'CC BY-NC SA 3.0': 'https://creativecommons.org/licenses/by-nc/3.0/',
-        "CC BY-NC-SA 4.0": 'https://creativecommons.org/licenses/by-nc/4.0/',
-        'MIT': 'https://opensource.org/licenses/MIT',
-        'GPL-3.0': 'https://opensource.org/licenses/GPL-3.0',
-        'US Public Domain': 'https://www.usa.gov/government-works',
-        'CC0: Public Domain': 'https://creativecommons.org/publicdomain/zero/1.0/',
-        'Apache 2.0': 'https://www.apache.org/licenses/LICENSE-2.0'}
-    if license == '':
-        license_msg = "This dataset has " \
-                      + _bold("no license") + ".\n"
+        "CC BY-SA 4.0": "https://creativecommons.org/licenses/by-sa/4.0/",
+        "CC BY-SA 3.0": "https://creativecommons.org/licenses/by-sa/3.0/",
+        "CC BY-NC 3.0": "https://creativecommons.org/licenses/by-nc/3.0/",
+        "CC BY-NC SA 3.0": "https://creativecommons.org/licenses/by-nc/3.0/",
+        "CC BY-NC-SA 4.0": "https://creativecommons.org/licenses/by-nc/4.0/",
+        "MIT": "https://opensource.org/licenses/MIT",
+        "GPL-3.0": "https://opensource.org/licenses/GPL-3.0",
+        "US Public Domain": "https://www.usa.gov/government-works",
+        "CC0: Public Domain": "https://creativecommons.org/publicdomain/zero/1.0/",
+        "Apache 2.0": "https://www.apache.org/licenses/LICENSE-2.0",
+    }
+    if license == "":
+        license_msg = "This dataset has " + _bold("no license") + ".\n"
     else:
-        license_msg = "This dataset is licensed under the " \
-                      + _bold(license) + " license.\n"
-        license_msg += "To learn more, visit: " \
-                       + _LICENSE_TO_URL[license] + "\n"
+        license_msg = "This dataset is licensed under the " + _bold(license) + " license.\n"
+        license_msg += "To learn more, visit: " + _LICENSE_TO_URL[license] + "\n"
 
-    if citation == '':
+    if citation == "":
         citation_msg = "This dataset has no associated citation."
     else:
         citation_msg = "When using this dataset, please cite the following:\n\n"
         citation_msg += citation
 
-    docs = load_public_sources()[name]['docs_url']
-    docs_msg = ("\nYou can find additional information about "
-                "this dataset at:\n" + docs)
+    docs = load_public_sources()[name]["docs_url"]
+    docs_msg = "\nYou can find additional information about " "this dataset at:\n" + docs
 
     columns = shutil.get_terminal_size((80, 24)).columns
-    max_print_length = max(min(
-        columns, max([len(i) for i in [
-            *citation_msg.split('\n'), *license_msg.split('\n')]])), columns)
-    print('\n' + '=' * max_print_length)
+    max_print_length = max(
+        min(
+            columns,
+            max([len(i) for i in [*citation_msg.split("\n"), *license_msg.split("\n")]]),
+        ),
+        columns,
+    )
+    print("\n" + "=" * max_print_length)
     print(first_msg)
     print(license_msg)
     print(citation_msg)
     print(docs_msg)
-    print("\nThis message will " + _bold("not") + " be automatically shown\n" 
-          "again. To view this message again, in an AgMLDataLoader\n" +
-          "run `loader.info.citation_summary()`. Otherwise, you\n" +
-          "can use `agml.data.source(<name>).citation_summary().`")
+    print(
+        "\nThis message will " + _bold("not") + " be automatically shown\n"
+        "again. To view this message again, in an AgMLDataLoader\n"
+        + "run `loader.info.citation_summary()`. Otherwise, you\n"
+        + "can use `agml.data.source(<name>).citation_summary().`"
+    )
 
     if location is not None:
         print(f"\nYou can find your dataset at {location}.")
-    print('=' * max_print_length)
+    print("=" * max_print_length)
     sys.stdout.flush()
-
-
-
-
-
diff --git a/agml/utils/downloads.py b/agml/utils/downloads.py
index 1596b4e1..fc82a9d2 100644
--- a/agml/utils/downloads.py
+++ b/agml/utils/downloads.py
@@ -16,13 +16,11 @@
 import shutil
 import zipfile
 
-from agml.utils.data import (
-    load_public_sources, maybe_you_meant, copyright_print
-)
-from agml.utils.logging import tqdm, log
+from agml.utils.data import copyright_print, load_public_sources, maybe_you_meant
+from agml.utils.logging import log, tqdm
 
 
-def download_dataset(dataset_name, dest_dir, redownload = False):
+def download_dataset(dataset_name, dest_dir, redownload=False):
     """
     Downloads a dataset from the agdata-data s3 file storage.
 
@@ -40,14 +38,13 @@ def download_dataset(dataset_name, dest_dir, redownload = False):
     # Validate dataset name
     source_info = load_public_sources()
     if dataset_name not in source_info.keys():
-        if dataset_name.replace('-', '_') not in source_info.keys():
+        if dataset_name.replace("-", "_") not in source_info.keys():
             msg = f"Received invalid public source: '{dataset_name}'."
             msg = maybe_you_meant(dataset_name, msg)
             raise ValueError(msg)
         else:
-            log(f"Interpreted dataset '{dataset_name}' as "
-                f"'{dataset_name.replace('-', '_')}.'")
-            dataset_name = dataset_name.replace('-', '_')
+            log(f"Interpreted dataset '{dataset_name}' as " f"'{dataset_name.replace('-', '_')}.'")
+            dataset_name = dataset_name.replace("-", "_")
 
     # Connect to S3 and generate unsigned URL for bucket object
     url = f"https://agdata-data.s3.us-west-1.amazonaws.com/datasets/{dataset_name}.zip"
@@ -58,32 +55,31 @@ def download_dataset(dataset_name, dest_dir, redownload = False):
     exist_dir = os.path.join(dest_dir, dataset_name)
     if not redownload:
         if os.path.exists(exist_dir):
-            log(f"Dataset '{dataset_name}' already exists "
-                f"in '{exist_dir}', skipping download.")
+            log(f"Dataset '{dataset_name}' already exists " f"in '{exist_dir}', skipping download.")
             return
     elif os.path.exists(exist_dir) and redownload:
         shutil.rmtree(exist_dir)
 
     # File path of zipped dataset
-    os.makedirs(dest_dir, exist_ok = True)
-    dataset_download_path = os.path.join(
-        dest_dir, dataset_name + '.zip')
+    os.makedirs(dest_dir, exist_ok=True)
+    dataset_download_path = os.path.join(dest_dir, dataset_name + ".zip")
 
     # Download object from bucket
     try:
         with requests.Session() as sess:
-            r = sess.get(url, stream = True)
+            r = sess.get(url, stream=True)
             r.raise_for_status()
-            content_size = int(r.headers['Content-Length'])
+            content_size = int(r.headers["Content-Length"])
             sz = round(content_size / 1000000, 1)
             size_print = f"{sz} MB"
             if sz > 1000:
                 size_print = f"{round(sz / 1000, 2)} GB"
-            pg = tqdm(total = content_size,
-                      desc = f"Downloading {dataset_name} "
-                             f"(size = {size_print})")
-            with open(dataset_download_path, 'wb') as f:
-                for chunk in r.iter_content(chunk_size = 8192):
+            pg = tqdm(
+                total=content_size,
+                desc=f"Downloading {dataset_name} " f"(size = {size_print})",
+            )
+            with open(dataset_download_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
                     pg.update(8192)
             pg.close()
@@ -97,10 +93,10 @@ def download_dataset(dataset_name, dest_dir, redownload = False):
         raise e
 
     # Unzip downloaded dataset
-    with zipfile.ZipFile(dataset_download_path, 'r') as z:
-        print(f'[AgML Download]: Extracting files for {dataset_name}... ', end = '')
-        z.extractall(path = dest_dir)
-        print('Done!')
+    with zipfile.ZipFile(dataset_download_path, "r") as z:
+        print(f"[AgML Download]: Extracting files for {dataset_name}... ", end="")
+        z.extractall(path=dest_dir)
+        print("Done!")
 
     # Delete zipped file
     if os.path.exists(dataset_download_path):
@@ -110,7 +106,7 @@ def download_dataset(dataset_name, dest_dir, redownload = False):
     copyright_print(dataset_name, os.path.splitext(dataset_download_path)[0])
 
 
-def download_model(model_name, dest_dir, redownload = False):
+def download_model(model_name, dest_dir, redownload=False):
     """
     Downloads a model from the agdata-data s3 file storage.
 
@@ -128,14 +124,13 @@ def download_model(model_name, dest_dir, redownload = False):
     # Validate dataset name
     source_info = load_public_sources()
     if model_name not in source_info.keys():
-        if model_name.replace('-', '_') not in source_info.keys():
+        if model_name.replace("-", "_") not in source_info.keys():
             msg = f"Received invalid public source: '{model_name}'."
             msg = maybe_you_meant(model_name, msg)
             raise ValueError(msg)
         else:
-            log(f"Interpreted dataset '{model_name}' as "
-                f"'{model_name.replace('-', '_')}.'")
-            model_name = model_name.replace('-', '_')
+            log(f"Interpreted dataset '{model_name}' as " f"'{model_name.replace('-', '_')}.'")
+            model_name = model_name.replace("-", "_")
 
     # Connect to S3 and generate unsigned URL for bucket object
     url = f"https://agdata-data.s3.us-west-1.amazonaws.com/models/{model_name}.pth"
@@ -146,31 +141,31 @@ def download_model(model_name, dest_dir, redownload = False):
     exist_dir = os.path.join(dest_dir, model_name)
     if not redownload:
         if os.path.exists(exist_dir):
-            log(f"Model '{model_name}' already exists "
-                f"in '{exist_dir}', skipping download.")
+            log(f"Model '{model_name}' already exists " f"in '{exist_dir}', skipping download.")
             return
     elif os.path.exists(exist_dir) and redownload:
         shutil.rmtree(exist_dir)
 
     # File path of model
-    os.makedirs(dest_dir, exist_ok = True)
-    model_download_path = os.path.join(dest_dir, model_name + '.pth')
+    os.makedirs(dest_dir, exist_ok=True)
+    model_download_path = os.path.join(dest_dir, model_name + ".pth")
 
     # Download object from bucket
     try:
         with requests.Session() as sess:
-            r = sess.get(url, stream = True)
+            r = sess.get(url, stream=True)
             r.raise_for_status()
-            content_size = int(r.headers['Content-Length'])
+            content_size = int(r.headers["Content-Length"])
             sz = round(content_size / 1000000, 1)
             size_print = f"{sz} MB"
             if sz > 1000:
                 size_print = f"{round(sz / 1000, 2)} GB"
-            pg = tqdm(total = content_size,
-                      desc = f"Downloading {model_name} "
-                             f"(size = {size_print})")
-            with open(model_download_path, 'wb') as f:
-                for chunk in r.iter_content(chunk_size = 8192):
+            pg = tqdm(
+                total=content_size,
+                desc=f"Downloading {model_name} " f"(size = {size_print})",
+            )
+            with open(model_download_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
                     pg.update(8192)
             pg.close()
@@ -184,7 +179,7 @@ def download_model(model_name, dest_dir, redownload = False):
         raise e
 
 
-def download_detector(detector_name, dest_dir, redownload = False):
+def download_detector(detector_name, dest_dir, redownload=False):
     """
     Downloads a detector from the agdata-data s3 file storage.
 
@@ -200,7 +195,7 @@ def download_detector(detector_name, dest_dir, redownload = False):
     import requests
 
     # Connect to S3 and generate unsigned URL for bucket object
-    detector_name_url = detector_name.replace('+', '%2B')
+    detector_name_url = detector_name.replace("+", "%2B")
     url = f"https://agdata-data.s3.us-west-1.amazonaws.com/models/detector/{detector_name_url}.zip"
 
     # Check if model already exists
@@ -209,31 +204,31 @@ def download_detector(detector_name, dest_dir, redownload = False):
     exist_dir = os.path.join(dest_dir, detector_name)
     if not redownload:
         if os.path.exists(exist_dir):
-            log(f"Model '{detector_name}' already exists "
-                f"in '{exist_dir}', skipping download.")
+            log(f"Model '{detector_name}' already exists " f"in '{exist_dir}', skipping download.")
             return
     elif os.path.exists(exist_dir) and redownload:
         shutil.rmtree(exist_dir)
 
     # File path of model
-    os.makedirs(dest_dir, exist_ok = True)
-    model_download_path = os.path.join(dest_dir, detector_name + '.zip')
+    os.makedirs(dest_dir, exist_ok=True)
+    model_download_path = os.path.join(dest_dir, detector_name + ".zip")
 
     # Download object from bucket
     try:
         with requests.Session() as sess:
-            r = sess.get(url, stream = True)
+            r = sess.get(url, stream=True)
             r.raise_for_status()
-            content_size = int(r.headers['Content-Length'])
+            content_size = int(r.headers["Content-Length"])
             sz = round(content_size / 1000000, 1)
             size_print = f"{sz} MB"
             if sz > 1000:
                 size_print = f"{round(sz / 1000, 2)} GB"
-            pg = tqdm(total = content_size,
-                      desc = f"Downloading {detector_name} "
-                             f"(size = {size_print})")
-            with open(model_download_path, 'wb') as f:
-                for chunk in r.iter_content(chunk_size = 8192):
+            pg = tqdm(
+                total=content_size,
+                desc=f"Downloading {detector_name} " f"(size = {size_print})",
+            )
+            with open(model_download_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
                     pg.update(8192)
             pg.close()
@@ -247,10 +242,10 @@ def download_detector(detector_name, dest_dir, redownload = False):
         raise e
 
     # Unzip downloaded dataset
-    with zipfile.ZipFile(model_download_path, 'r') as z:
-        print(f'[AgML Download]: Extracting files for {detector_name}... ', end = '')
-        z.extractall(path = dest_dir)
-        print('Done!')
+    with zipfile.ZipFile(model_download_path, "r") as z:
+        print(f"[AgML Download]: Extracting files for {detector_name}... ", end="")
+        z.extractall(path=dest_dir)
+        print("Done!")
 
     # Delete zipped file
     if os.path.exists(model_download_path):
diff --git a/agml/utils/general.py b/agml/utils/general.py
index 8312dd42..11b5071f 100644
--- a/agml/utils/general.py
+++ b/agml/utils/general.py
@@ -12,18 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import re
-import cv2
 import glob
 import math
-import matplotlib.pyplot as plt
-import matplotlib.patches as patches
-
-from math import pi, floor
-from scipy import signal
+import re
+from math import floor, pi
 
+import cv2
+import matplotlib.patches as patches
+import matplotlib.pyplot as plt
 import numpy as np
-
+from scipy import signal
 
 # Represents an empty object, but allows passing `None`
 # as an independent object in certain cases.
@@ -37,8 +35,8 @@ def placeholder(obj):
 
 def to_camel_case(s):
     """Converts a given string `s` to camel case."""
-    s = re.sub(r"(_|-)+", " ", s).title().replace(" ", "") # noqa
-    return ''.join(s)
+    s = re.sub(r"(_|-)+", " ", s).title().replace(" ", "")  # noqa
+    return "".join(s)
 
 
 def resolve_list_value(val):
@@ -48,21 +46,27 @@ def resolve_list_value(val):
     return val
 
 
-def resolve_tuple_values(*inputs, custom_error = None):
-    """Determines whether values are distributed amongst the values in `inputs`. """
+def resolve_tuple_values(*inputs, custom_error=None):
+    """Determines whether values are distributed amongst the values in `inputs`."""
     if isinstance(inputs[0], (list, tuple)) and all(c is None for c in inputs[1:]):
         if len(inputs[0]) != len(inputs):
             # special case for COCO JSON
             if len(inputs) == 3 and len(inputs[0]) == 2 and isinstance(inputs[0][1], dict):
                 try:
-                    return inputs[0][0], inputs[0][1]['bbox'], inputs[0][1]['category_id']
+                    return (
+                        inputs[0][0],
+                        inputs[0][1]["bbox"],
+                        inputs[0][1]["category_id"],
+                    )
                 except KeyError:
-                    return inputs[0][0], inputs[0][1]['bboxes'], inputs[0][1]['labels']
+                    return inputs[0][0], inputs[0][1]["bboxes"], inputs[0][1]["labels"]
             if custom_error is not None:
                 raise ValueError(custom_error)
             else:
-                raise ValueError(f"Expected either a tuple with {len(inputs)} values "
-                                 f"or {len(inputs)} values across two arguments.")
+                raise ValueError(
+                    f"Expected either a tuple with {len(inputs)} values "
+                    f"or {len(inputs)} values across two arguments."
+                )
         else:
             return inputs[0]
     return inputs
@@ -89,9 +93,11 @@ def as_scalar(inp):
     if isinstance(inp, np.ndarray):
         return inp.item()
     from agml.backend.tftorch import torch
+
     if isinstance(inp, torch.Tensor):
         return inp.item()
     from agml.backend.tftorch import tf
+
     if isinstance(inp, tf.Tensor):
         return inp.numpy()
     raise TypeError(f"Unsupported variable type {type(inp)}.")
@@ -107,9 +113,11 @@ def is_array_like(inp):
     if isinstance(inp, np.ndarray):
         return True
     from agml.backend.tftorch import torch
+
     if isinstance(inp, torch.Tensor):
         return True
     from agml.backend.tftorch import tf
+
     if isinstance(inp, tf.Tensor):
         return True
     return False
@@ -118,17 +126,17 @@ def is_array_like(inp):
 def shapes(seq):
     """Returns the shapes (or lengths) of all of the objects in the sequence."""
     try:
-        return [getattr(obj, 'shape', len(obj)) for obj in seq]
+        return [getattr(obj, "shape", len(obj)) for obj in seq]
     except:
         raise ValueError(f"One or more of the objects has no shape or length: {seq}.")
 
 
-def weak_squeeze(arr, ndims = 2):
+def weak_squeeze(arr, ndims=2):
     """Performs a 'weak squeeze', adding a dimension back if necessary."""
     if isinstance(arr, np.ndarray):
         arr = np.squeeze(arr)
         while arr.ndim < ndims:
-            arr = np.expand_dims(arr, axis = 0)
+            arr = np.expand_dims(arr, axis=0)
     if isinstance(arr, list):
         while len(arr) < ndims:
             arr = [arr]
@@ -138,7 +146,8 @@ def weak_squeeze(arr, ndims = 2):
 def is_float(num):
     """Determines if a number is a float."""
     is_ = isinstance(num, float) or isinstance(num, np.float32) or isinstance(num, np.float64)
-    if is_: return True
+    if is_:
+        return True
     try:
         float(num)
     except ValueError:
@@ -149,7 +158,8 @@ def is_float(num):
 def is_int(num):
     """Determines if a number is an int."""
     is_ = isinstance(num, int) or isinstance(num, np.int32) or isinstance(num, np.int64)
-    if is_: return True
+    if is_:
+        return True
     try:
         int(num)
     except ValueError:
diff --git a/agml/utils/image.py b/agml/utils/image.py
index a4f1a75d..462e7e59 100644
--- a/agml/utils/image.py
+++ b/agml/utils/image.py
@@ -35,9 +35,8 @@ def consistent_shapes(objects):
 
 def needs_batch_dim(image):
     """Determines whether an image has or is missing a batch dimension."""
-    if not hasattr(image, 'shape'):
-        raise TypeError(
-            "Can only determine batch dimensions for numpy arrays or tensors.")
+    if not hasattr(image, "shape"):
+        raise TypeError("Can only determine batch dimensions for numpy arrays or tensors.")
     if len(image.shape) == 2:
         return True
     elif len(image.shape) == 3:
@@ -51,13 +50,12 @@ def resolve_image_size(size):
         return size, size
     elif isinstance(size, (list, tuple, set, np.ndarray)):
         if not len(size) == 2:
-            raise ValueError(
-                "Only two values must be provided for an input image size.")
+            raise ValueError("Only two values must be provided for an input image size.")
         return size
     else:
         raise ValueError(
-            f"Expected either an integer or list of two values for "
-            f"image size, got ({size}) of type ({type(size)}).")
+            f"Expected either an integer or list of two values for " f"image size, got ({size}) of type ({type(size)})."
+        )
 
 
 class imread_context(object):
@@ -70,35 +68,36 @@ class imread_context(object):
     error message in future operations. This context catches such
     issues and raises a more detailed error message for the user.
     """
-    def __init__(self, path, flags = None):
+
+    def __init__(self, path, flags=None):
         self._path = path
         if not os.path.exists(path):
             raise ValueError(
                 f"The image path '{path}' does not exist. "
                 f"Please check the dataset you are using, "
-                f"and if files are missing, re-download it.")
+                f"and if files are missing, re-download it."
+            )
         self.flags = flags
         if self.flags is None:
             self.flags = cv2.IMREAD_UNCHANGED
 
     def __enter__(self):
         try:
-
             img = cv2.imread(self._path, self.flags)
         except cv2.error:
             raise ValueError(
                 f"An error was encountered when loading the image "
                 f"'{self._path}'. Please check the dataset you are "
-                f"using and re-download it if files are missing.")
+                f"using and re-download it if files are missing."
+            )
         else:
             if img is None:
                 raise ValueError(
                     f"The image at '{self._path}' is empty,"
                     f" corrupted, or could not be read. Please "
-                    f"re-download the dataset you are using.")
+                    f"re-download the dataset you are using."
+                )
         return img
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         pass
-
-
diff --git a/agml/utils/io.py b/agml/utils/io.py
index bbfeb84d..41506769 100644
--- a/agml/utils/io.py
+++ b/agml/utils/io.py
@@ -14,9 +14,8 @@
 
 import os
 
-
 # Files which shouldn't be included in a file list.
-EXCLUDED_FILES: list = ['.DS_Store']
+EXCLUDED_FILES: list = [".DS_Store"]
 
 
 def _is_valid_file(file):
@@ -27,39 +26,37 @@ def _is_valid_file(file):
     """
     global EXCLUDED_FILES
     if os.path.isfile(file):
-        if not file.startswith('.git') and file not in EXCLUDED_FILES:
+        if not file.startswith(".git") and file not in EXCLUDED_FILES:
             return True
     return False
 
 
-def get_file_list(fpath, ext = None, full_paths = True):
+def get_file_list(fpath, ext=None, full_paths=True):
     """Gets a list of files from a path."""
-    base_list = [os.path.join(fpath, f) if full_paths else f
-                 for f in os.listdir(fpath)
-                 if _is_valid_file(os.path.join(fpath, f))]
+    base_list = [
+        os.path.join(fpath, f) if full_paths else f for f in os.listdir(fpath) if _is_valid_file(os.path.join(fpath, f))
+    ]
     if ext is not None:
         if callable(ext):
             return [f for f in base_list if ext(f)]
         if isinstance(ext, str):
             return [f for f in base_list if f.endswith(ext)]
         else:
-            return [f for f in base_list if
-                    any([f.endswith(i) for i in ext])]
+            return [f for f in base_list if any([f.endswith(i) for i in ext])]
     return base_list
 
 
 def get_dir_list(filepath):
     """Get a list of directories from a path."""
-    return [f for f in os.listdir(filepath)
-            if os.path.isdir(os.path.join(filepath, f))]
+    return [f for f in os.listdir(filepath) if os.path.isdir(os.path.join(filepath, f))]
 
 
 def nested_dir_list(fpath):
     """Returns a nested list of directories from a path."""
     dirs = []
-    for f in os.scandir(fpath): # type: os.DirEntry
+    for f in os.scandir(fpath):  # type: os.DirEntry
         if f.is_dir():
-            if not os.path.basename(f.path).startswith('.'):
+            if not os.path.basename(f.path).startswith("."):
                 dirs.append(os.path.join(fpath, f.path))
     if len(dirs) != 0:
         for dir_ in dirs:
@@ -67,23 +64,23 @@ def nested_dir_list(fpath):
     return dirs
 
 
-def nested_file_list(fpath, ext = None):
+def nested_file_list(fpath, ext=None):
     """Returns a nested list of files from a path."""
-    if ext == 'image':
-        ext = ['jpg', 'jpeg', 'png', 'bmp', 'tiff']
-    files = get_file_list(fpath, ext = ext)
+    if ext == "image":
+        ext = ["jpg", "jpeg", "png", "bmp", "tiff"]
+    files = get_file_list(fpath, ext=ext)
     dirs = nested_dir_list(fpath)
     for dir_ in dirs:
-        files.extend(get_file_list(dir_, ext = ext))
+        files.extend(get_file_list(dir_, ext=ext))
     return files
 
 
 def create_dir(dir_):
     """Creates a directory (or does nothing if it exists)."""
-    os.makedirs(dir_, exist_ok = True)
+    os.makedirs(dir_, exist_ok=True)
 
 
-def recursive_dirname(dir_, level = 1):
+def recursive_dirname(dir_, level=1):
     """Returns a recursive dirname for the number of levels provided."""
     if level == 0:
         return dir_
@@ -95,24 +92,22 @@ def is_image_file(file):
     if not isinstance(file, (str, bytes, os.PathLike)):
         return False
     end = os.path.splitext(file)[-1][1:]
-    return end.lower() in ['jpg', 'jpeg', 'png', 'bmp', 'tiff']
+    return end.lower() in ["jpg", "jpeg", "png", "bmp", "tiff"]
 
 
 def load_code_from_string_or_file(code):
     """Returns valid code either from the file `code` or the string `code`."""
     if not isinstance(code, str):
         raise TypeError(
-            f"`code` must be either a code string or a path to "
-            f"a code file, got {code} of type ({type(code)}).")
+            f"`code` must be either a code string or a path to " f"a code file, got {code} of type ({type(code)})."
+        )
 
     # Check if it is a path. Just because the path doesn't exist doesn't mean
     # that it isn't a path: it could be an incorrect path.
     if os.path.exists(code):
-        with open(code, 'r') as f:
+        with open(code, "r") as f:
             code = f.read()
     else:
-        if code.endswith('.cpp') or code.endswith('.cc') \
-                or code.endswith('.txt') or code.endswith('.py'):
+        if code.endswith(".cpp") or code.endswith(".cc") or code.endswith(".txt") or code.endswith(".py"):
             raise ValueError(f"The provided file at {code} could not be found.")
     return code
-
diff --git a/agml/utils/logging.py b/agml/utils/logging.py
index 4c1820fe..2204019e 100644
--- a/agml/utils/logging.py
+++ b/agml/utils/logging.py
@@ -12,16 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import inspect
+import logging
 import os
 import sys
 import time
-import inspect
-import logging
-
 
 # This is a simple hack to auto-adjust `tqdm` based on whether
 # we are in a Jupyter notebook or in a regular shell environment.
-if 'get_ipython' in globals():
+if "get_ipython" in globals():
     from tqdm.notebook import tqdm
 else:
     from tqdm import tqdm
@@ -33,11 +32,12 @@
 
 # Configure the logger.
 logging.basicConfig(
-    format = '%(asctime)s %(levelname)s - %(name)s: %(message)s',
-    datefmt = '%m-%d-%Y %H:%M:%S')
+    format="%(asctime)s %(levelname)s - %(name)s: %(message)s",
+    datefmt="%m-%d-%Y %H:%M:%S",
+)
 
 
-def log(msg, level = logging.WARNING):
+def log(msg, level=logging.WARNING):
     """Logs a message to the console.
 
     This is an internal wrapper method for the logging module,
@@ -49,10 +49,10 @@ def log(msg, level = logging.WARNING):
         logging.INFO: logging.info,
         logging.WARNING: logging.warning,
         logging.CRITICAL: logging.critical,
-        'debug': logging.debug,
-        'info': logging.info,
-        'warning': logging.warning,
-        'critical': logging.critical
+        "debug": logging.debug,
+        "info": logging.info,
+        "warning": logging.warning,
+        "critical": logging.critical,
     }
 
     # Check if the warning has been delivered recently.
@@ -61,7 +61,7 @@ def log(msg, level = logging.WARNING):
     msg = "[AgML] " + msg
     if save_hash in _GIVEN_WARNINGS.keys():
         if _GIVEN_WARNINGS[save_hash] == msg:
-            save_time = float(save_hash.split(':')[0])
+            save_time = float(save_hash.split(":")[0])
             if time.time() - save_time > 240:
                 log_method(msg)
     else:
@@ -79,11 +79,11 @@ class no_print(object):
     > print("This will be printed.")
     This will be printed.
     """
+
     def __enter__(self):
         self._stdout_reset = sys.stdout
-        sys.stdout = open(os.devnull, 'w')
+        sys.stdout = open(os.devnull, "w")
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         sys.stdout.close()
         sys.stdout = self._stdout_reset
-
diff --git a/agml/utils/random.py b/agml/utils/random.py
index 624f0e2b..d8c11e95 100644
--- a/agml/utils/random.py
+++ b/agml/utils/random.py
@@ -49,12 +49,12 @@ def reset(self):
 def inject_random_state(f):
     """Runs a method inside of a context if a random seed is provided."""
     if "{random_state}" in f.__doc__:
-        f.__doc__ = f.__doc__.format(random_state = _RANDOM_STATE_DOC)
+        f.__doc__ = f.__doc__.format(random_state=_RANDOM_STATE_DOC)
     else:
         f.__doc__ += _RANDOM_STATE_DOC
 
     @functools.wraps(f)
-    def _run(*args, random_state = None, **kwargs):
+    def _run(*args, random_state=None, **kwargs):
         # If no random state is provided, run the method as normal.
         if random_state is None:
             return f(*args, **kwargs)
@@ -64,10 +64,11 @@ def _run(*args, random_state = None, **kwargs):
             raise TypeError(
                 f"Expected `random_state` argument to be "
                 f"an integer, instead got ({random_state}) "
-                f"of type ({type(random_state)}).")
+                f"of type ({type(random_state)})."
+            )
 
         with seed_context(random_state):
             result = f(*args, **kwargs)
         return result
-    return _run
 
+    return _run
diff --git a/agml/viz/__init__.py b/agml/viz/__init__.py
index e0c82a73..3f15b75a 100644
--- a/agml/viz/__init__.py
+++ b/agml/viz/__init__.py
@@ -12,38 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .tools import (
-    format_image,
-    set_colormap,
-    get_colormap,
-    convert_figure_to_image,
-    set_viz_backend,
-    get_viz_backend
-)
+from .boxes import annotate_object_detection, show_image_and_boxes, show_object_detection_truth_and_prediction
+from .display import display_image
+from .general import show_images, show_sample
+from .inspection import plot_synthetic_camera_positions, visualize_all_views
+from .labels import show_images_and_labels
 from .masks import (
-    convert_mask_to_colored_image,
     annotate_semantic_segmentation,
+    convert_mask_to_colored_image,
     show_image_and_mask,
     show_image_and_overlaid_mask,
     show_semantic_segmentation_truth_and_prediction,
 )
-from .boxes import (
-    annotate_object_detection,
-    show_image_and_boxes,
-    show_object_detection_truth_and_prediction
-)
-from .labels import (
-    show_images_and_labels
-)
-from .general import (
-    show_sample,
-    show_images
-)
-from .inspection import (
-    plot_synthetic_camera_positions,
-    visualize_all_views
-)
-from .point_clouds import (
-    show_point_cloud
-)
-from .display import display_image
+from .point_clouds import show_point_cloud
+from .tools import convert_figure_to_image, format_image, get_colormap, get_viz_backend, set_colormap, set_viz_backend
diff --git a/agml/viz/boxes.py b/agml/viz/boxes.py
index 91670590..dde96e46 100644
--- a/agml/viz/boxes.py
+++ b/agml/viz/boxes.py
@@ -13,15 +13,13 @@
 # limitations under the License.
 
 import cv2
-import numpy as np
 import matplotlib.pyplot as plt
+import numpy as np
 
-from agml.utils.general import (
-    resolve_tuple_values, weak_squeeze, scalar_unpack, as_scalar
-)
 from agml.data.tools import convert_bbox_format
-from agml.viz.tools import format_image, get_colormap, convert_figure_to_image
+from agml.utils.general import as_scalar, resolve_tuple_values, scalar_unpack, weak_squeeze
 from agml.viz.display import display_image
+from agml.viz.tools import convert_figure_to_image, format_image, get_colormap
 
 
 def _resolve_proportional_bboxes(coords, shape):
@@ -33,24 +31,18 @@ def _resolve_proportional_bboxes(coords, shape):
     if all(isinstance(i, float) for i in coords):
         if coords[0] <= 1:
             x, y, width, height = coords
-            y *= shape[0]; height *= shape[0]  # noqa
-            x *= shape[1]; width *= shape[1]  # noqa
+            y *= shape[0]
+            height *= shape[0]  # noqa
+            x *= shape[1]
+            width *= shape[1]  # noqa
             coords = [x, y, width, height]
         return [int(round(c)) for c in coords]
     elif all(isinstance(i, int) for i in coords):
         return coords
-    raise TypeError(
-        f"Got multiple types for coordinates: "
-        f"{[type(i) for i in coords]}.")
-
-
-def annotate_object_detection(image,
-                              bboxes = None,
-                              labels = None,
-                              inplace = True,
-                              info = None,
-                              bbox_format = None,
-                              **kwargs):
+    raise TypeError(f"Got multiple types for coordinates: " f"{[type(i) for i in coords]}.")
+
+
+def annotate_object_detection(image, bboxes=None, labels=None, inplace=True, info=None, bbox_format=None, **kwargs):
     """Annotates bounding boxes onto an image.
 
     This method will annotate the given bounding boxes directly onto the image,
@@ -90,24 +82,27 @@ def annotate_object_detection(image,
     # user just called `agml.viz.put_boxes_on_image(loader[0])`), or whether
     # the relevant values have been passed to the keyword arguments.
     image, bboxes, labels = resolve_tuple_values(
-        image, bboxes, labels, custom_error =
-        "If `image` is a tuple/list, it should contain "
-        "three values: the image, mask, and (optionally) labels."
+        image,
+        bboxes,
+        labels,
+        custom_error="If `image` is a tuple/list, it should contain "
+        "three values: the image, mask, and (optionally) labels.",
     )
 
     # If the user passed a COCO JSON dictionary for `bboxes`, resolve it into
     # a list of bounding boxes and its corresponding labels.
     if isinstance(bboxes, dict):
         try:
-            bboxes, labels = bboxes['bbox'], bboxes['category_id']
+            bboxes, labels = bboxes["bbox"], bboxes["category_id"]
         except KeyError:
             try:
-                bboxes, labels = bboxes['bboxes'], bboxes['labels']
+                bboxes, labels = bboxes["bboxes"], bboxes["labels"]
             except KeyError:
                 raise ValueError(
                     "Unexpected COCO JSON format found in input `bboxes` "
                     "dictionary, got {list(bboxes.keys())} but expected "
-                    "either `bbox` or `bboxes` for bounding boxes.")
+                    "either `bbox` or `bboxes` for bounding boxes."
+                )
 
     # If there are no bounding boxes, then simply return the image.
     if len(bboxes) == 0:
@@ -118,20 +113,20 @@ def annotate_object_detection(image,
         bboxes = convert_bbox_format(bboxes, bbox_format)
 
     # Run a few final checks in order to ensure data is formatted properly.
-    image = format_image(image, mask = False).copy()
+    image = format_image(image, mask=False).copy()
     if not inplace:
         image = image.copy()
-    bboxes = weak_squeeze(bboxes, ndims = 2)
+    bboxes = weak_squeeze(bboxes, ndims=2)
     if labels is None:
         labels = [0] * len(bboxes)
-    labels = weak_squeeze(labels, ndims = 1)
+    labels = weak_squeeze(labels, ndims=1)
 
     # Check for any additional information that can be used to annotate labels.
     annotate_with_info = False
     if info is not None:
-        if kwargs.get('num_to_class') is not None:
+        if kwargs.get("num_to_class") is not None:
             annotate_with_info = True
-            info = kwargs['num_to_class']
+            info = kwargs["num_to_class"]
 
         elif all(isinstance(label, str) for label in labels):
             # If the labels are already strings, then create an info dictionary
@@ -142,7 +137,7 @@ def annotate_object_detection(image,
             info = {v: k for k, v in label_map.items()}
             labels = [label_map[j] for j in labels]
 
-        elif hasattr(info, 'num_to_class'):
+        elif hasattr(info, "num_to_class"):
             annotate_with_info = True
             info = info.num_to_class
 
@@ -150,7 +145,7 @@ def annotate_object_detection(image,
             annotate_with_info = True
 
     # Check the keyword arguments for any additional information that can be used.
-    thickness = kwargs.get('thickness', 2)
+    thickness = kwargs.get("thickness", 2)
 
     # Iterate over each bounding box and label, and annotate them onto the image.
     cmap = get_colormap()
@@ -162,8 +157,7 @@ def annotate_object_detection(image,
         x2, y2 = bbox[2] + x, bbox[3] + y
 
         # Annotate the bounding box onto the image.
-        cv2.rectangle(image, (x, y), (x2, y2), color = cmap[as_scalar(label)],
-                      thickness = thickness)
+        cv2.rectangle(image, (x, y), (x2, y2), color=cmap[as_scalar(label)], thickness=thickness)
 
         # If the user passed additional information, annotate it onto the image
         # by putting the text above the bounding box with the corresponding label.
@@ -174,54 +168,58 @@ def annotate_object_detection(image,
                 text = info[label + 1]
 
             # Get the text size.
-            (label_width, label_height), baseline = cv2.getTextSize(
-                text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)
+            (label_width, label_height), baseline = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)
 
             # Calculate the coordinates of the background rectangle of the label.
             x, y = bbox[0], bbox[1] - label_height - baseline
             x2, y2 = x + label_width, y + label_height + baseline
 
             # Annotate the background rectangle and label text onto the image.
-            cv2.rectangle(image, (x, y), (x2, y2), color = cmap[label], thickness = -1)
-            cv2.putText(image, text, (x, y + label_height),
-                        cv2.FONT_HERSHEY_DUPLEX, 0.5, (0, 0, 0), 1)
+            cv2.rectangle(image, (x, y), (x2, y2), color=cmap[label], thickness=-1)
+            cv2.putText(
+                image,
+                text,
+                (x, y + label_height),
+                cv2.FONT_HERSHEY_DUPLEX,
+                0.5,
+                (0, 0, 0),
+                1,
+            )
 
     # Return the image.
     return image
 
 
-def show_image_and_boxes(image,
-                         bboxes = None,
-                         labels = None,
-                         inplace = True,
-                         info = None,
-                         bbox_format = None,
-                         **kwargs):
+def show_image_and_boxes(image, bboxes=None, labels=None, inplace=True, info=None, bbox_format=None, **kwargs):
     """Visualizes an image with annotated bounding boxes."""
     # Annotate the bounding boxes onto the image.
-    image = annotate_object_detection(image = image,
-                                      bboxes = bboxes,
-                                      labels = labels,
-                                      inplace = inplace,
-                                      info = info,
-                                      bbox_format = bbox_format,
-                                      **kwargs)
+    image = annotate_object_detection(
+        image=image,
+        bboxes=bboxes,
+        labels=labels,
+        inplace=inplace,
+        info=info,
+        bbox_format=bbox_format,
+        **kwargs,
+    )
 
     # Display the image.
-    if not kwargs.get('no_show', False):
+    if not kwargs.get("no_show", False):
         _ = display_image(image, force_show=True)
     return image
 
 
-def show_object_detection_truth_and_prediction(image,
-                                               real_boxes = None,
-                                               real_labels = None,
-                                               predicted_boxes = None,
-                                               predicted_labels = None,
-                                               inplace = True,
-                                               info = None,
-                                               bbox_format = None,
-                                               **kwargs):
+def show_object_detection_truth_and_prediction(
+    image,
+    real_boxes=None,
+    real_labels=None,
+    predicted_boxes=None,
+    predicted_labels=None,
+    inplace=True,
+    info=None,
+    bbox_format=None,
+    **kwargs,
+):
     """Visualizes the ground truth and prediction of an object detection model.
 
     Parameters
@@ -277,15 +275,18 @@ def show_object_detection_truth_and_prediction(image,
             image, real_boxes, real_labels, predicted_boxes, predicted_labels = image
     else:
         # Otherwise, check that the first three arguments have been passed.
-        if real_boxes is not None and real_labels is not None and \
-                predicted_boxes is None and predicted_labels is None:
+        if real_boxes is not None and real_labels is not None and predicted_boxes is None and predicted_labels is None:
             if isinstance(real_boxes, dict) and isinstance(real_labels, dict):
                 predicted_boxes = real_labels
                 real_labels = None
 
         # Otherwise, check that the first FOUR arguments have been passed.
-        if real_boxes is not None and real_labels is not None and \
-                predicted_boxes is not None and predicted_labels is None:
+        if (
+            real_boxes is not None
+            and real_labels is not None
+            and predicted_boxes is not None
+            and predicted_labels is None
+        ):
             # The real annotations are a COCO JSON dict and predicted annotations
             # are two input arrays. The other case is redundant since it is technically
             # correct in formatting, so we don't do anything.
@@ -299,37 +300,36 @@ def show_object_detection_truth_and_prediction(image,
             pass
 
     # Generate the two images: real and predicted.
-    real_image = annotate_object_detection(image = image,
-                                           bboxes = real_boxes,
-                                           labels = real_labels,
-                                           inplace = inplace,
-                                           info = info,
-                                           bbox_format = bbox_format,
-                                           **kwargs)
-    predicted_image = annotate_object_detection(image = image,
-                                                bboxes = predicted_boxes,
-                                                labels = predicted_labels,
-                                                inplace = inplace,
-                                                info = info,
-                                                bbox_format = bbox_format,
-                                                **kwargs)
-
+    real_image = annotate_object_detection(
+        image=image,
+        bboxes=real_boxes,
+        labels=real_labels,
+        inplace=inplace,
+        info=info,
+        bbox_format=bbox_format,
+        **kwargs,
+    )
+    predicted_image = annotate_object_detection(
+        image=image,
+        bboxes=predicted_boxes,
+        labels=predicted_labels,
+        inplace=inplace,
+        info=info,
+        bbox_format=bbox_format,
+        **kwargs,
+    )
 
     # Create two side-by-side figures with the images.
-    fig, axes = plt.subplots(1, 2, figsize = (12, 6))
-    for ax, img, label in zip(
-            axes, (real_image, predicted_image),
-            ("Ground Truth Boxes", "Predicted Boxes")):
+    fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+    for ax, img, label in zip(axes, (real_image, predicted_image), ("Ground Truth Boxes", "Predicted Boxes")):
         ax.imshow(img)
         ax.set_axis_off()
-        ax.set_title(label, fontsize = 15)
-        ax.set_aspect('equal')
+        ax.set_title(label, fontsize=15)
+        ax.set_aspect("equal")
     fig.tight_layout()
 
     # Display and return the image.
     image = convert_figure_to_image()
-    if not kwargs.get('no_show', False):
+    if not kwargs.get("no_show", False):
         _ = display_image(image)
     return image
-
-
diff --git a/agml/viz/display.py b/agml/viz/display.py
index 7ddf24f5..2b14a0ff 100644
--- a/agml/viz/display.py
+++ b/agml/viz/display.py
@@ -16,8 +16,9 @@
 
 import cv2
 import matplotlib.pyplot as plt
-from PIL import Image, ExifTags
 import numpy as np
+from PIL import ExifTags, Image
+
 from agml.viz.tools import get_viz_backend
 
 
@@ -26,7 +27,7 @@ def correct_image_orientation(image):
     try:
         pil_image = Image.fromarray(image)
         for orientation in ExifTags.TAGS.keys():
-            if ExifTags.TAGS[orientation] == 'Orientation':
+            if ExifTags.TAGS[orientation] == "Orientation":
                 break
         exif = pil_image._getexif()
         if exif is not None:
@@ -52,20 +53,20 @@ def display_image(image, **kwargs):
     notebook = False
     try:
         shell = eval("get_ipython().__class__.__name__")
-        if shell == 'ZMQInteractiveShell':
+        if shell == "ZMQInteractiveShell":
             notebook = True
     except NameError:
         pass
 
-    if get_viz_backend() == 'cv2':
+    if get_viz_backend() == "cv2":
         # If running in Colab, then use a separate procedure.
-        if 'google.colab' in sys.modules:
+        if "google.colab" in sys.modules:
             try:
                 from google.colab.patches import cv2_imshow
             except ImportError:
                 raise ImportError(
-                    "Can't import cv2_imshow from google.colab.patches. "
-                    "Use the matplotlib backend for `agml.viz`.")
+                    "Can't import cv2_imshow from google.colab.patches. " "Use the matplotlib backend for `agml.viz`."
+                )
             cv2_imshow(image)
             return
 
@@ -73,31 +74,29 @@ def display_image(image, **kwargs):
         # displays images in the background, so don't actually do anything here.
         if notebook:
             # If the input content is not a figure, then we can display it.
-            if kwargs.get('matplotlib_figure', True):
+            if kwargs.get("matplotlib_figure", True):
                 return
 
         else:
-            if kwargs.get('read_raw', False):
-                image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) # convert back to BGR
-            cv2.imshow('image', image)
+            if kwargs.get("read_raw", False):
+                image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)  # convert back to BGR
+            cv2.imshow("image", image)
             cv2.waitKey(0)
-            cv2.destroyWindow('image')
+            cv2.destroyWindow("image")
             return
 
-    if get_viz_backend() == 'matplotlib':
+    if get_viz_backend() == "matplotlib":
         # If we are in a notebook or Colab, then don't show anything (since
         # it will be displayed automatically due to the way notebooks are).
         #
         # But also, some methods don't have any Matplotlib functions - so
         # for those we bypass this skip just to show the result.
-        if 'google.colab' in sys.modules or notebook and not kwargs.get('force_show', False):
+        if "google.colab" in sys.modules or notebook and not kwargs.get("force_show", False):
             return
 
     # Default case is matplotlib, since it is the most modular.
-    fig = plt.figure(figsize = (10, 10))
+    fig = plt.figure(figsize=(10, 10))
     plt.imshow(image)
-    plt.gca().axis('off')
-    plt.gca().set_aspect('equal')
+    plt.gca().axis("off")
+    plt.gca().set_aspect("equal")
     plt.show()
-
-
diff --git a/agml/viz/general.py b/agml/viz/general.py
index 0e7d5ac5..bc23017a 100644
--- a/agml/viz/general.py
+++ b/agml/viz/general.py
@@ -16,10 +16,10 @@
 
 from agml.backend.tftorch import is_array_like
 from agml.viz.boxes import show_image_and_boxes
-from agml.viz.masks import show_image_and_overlaid_mask
-from agml.viz.labels import show_images_and_labels
-from agml.viz.tools import format_image, _inference_best_shape, convert_figure_to_image
 from agml.viz.display import display_image
+from agml.viz.labels import show_images_and_labels
+from agml.viz.masks import show_image_and_overlaid_mask
+from agml.viz.tools import _inference_best_shape, convert_figure_to_image, format_image
 
 
 def show_sample(loader, image_only=False, num_images=1, **kwargs):
@@ -48,24 +48,23 @@ def show_sample(loader, image_only=False, num_images=1, **kwargs):
     if image_only:
         return show_images([sample[0] for sample in samples])
 
-    if loader.task == 'object_detection':
-        return [show_image_and_boxes(
-            sample, info=loader.info,
-            no_show=kwargs.get('no_show', False),
-            num_to_class=kwargs.get('num_to_class', None))
-            for sample in samples]
-    elif loader.task == 'semantic_segmentation':
-        return [show_image_and_overlaid_mask(
-            sample, no_show=kwargs.get('no_show', False))
-            for sample in samples]
-    elif loader.task == 'image_classification':
-        return show_images_and_labels(
-            samples, info=loader.info, no_show=kwargs.get('no_show', False))
-
-
-def show_images(images,
-                shape = None,
-                **kwargs):
+    if loader.task == "object_detection":
+        return [
+            show_image_and_boxes(
+                sample,
+                info=loader.info,
+                no_show=kwargs.get("no_show", False),
+                num_to_class=kwargs.get("num_to_class", None),
+            )
+            for sample in samples
+        ]
+    elif loader.task == "semantic_segmentation":
+        return [show_image_and_overlaid_mask(sample, no_show=kwargs.get("no_show", False)) for sample in samples]
+    elif loader.task == "image_classification":
+        return show_images_and_labels(samples, info=loader.info, no_show=kwargs.get("no_show", False))
+
+
+def show_images(images, shape=None, **kwargs):
     """Shows multiple images in a grid format with the given shape.
 
     Given a set of images, this method will generate a grid for the
@@ -92,7 +91,7 @@ def show_images(images,
     if not isinstance(images, (list, tuple)):
         if is_array_like(images):
             images = format_image(images)
-            if not kwargs.get('no_show', False):
+            if not kwargs.get("no_show", False):
                 display_image(images)
             return images
 
@@ -104,30 +103,25 @@ def show_images(images,
         shape = _inference_best_shape(len(images))
     if max(shape) > 20:
         raise NotImplementedError(
-            "Length of maximum shape length is greater than 20. "
-            "This method does not support non-rectangular shapes.")
+            "Length of maximum shape length is greater than 20. " "This method does not support non-rectangular shapes."
+        )
 
-    fig, axes = plt.subplots(
-        shape[0], shape[1], figsize = (shape[1] * 2, shape[0] * 2))
+    fig, axes = plt.subplots(shape[0], shape[1], figsize=(shape[1] * 2, shape[0] * 2))
     try:
         iter_ax = axes.flat
-    except AttributeError: # If showing only a single image.
+    except AttributeError:  # If showing only a single image.
         iter_ax = [axes]
     for image, ax in zip(images, iter_ax):
         ax.imshow(format_image(image))
         ax.set_aspect(1)
         ax.set_xticklabels([])
         ax.set_yticklabels([])
-        ax.tick_params(
-            axis = 'both', which = 'both', bottom = False,
-            top = False, left = False, right = False
-        )
-        plt.setp(ax.spines.values(), visible = False)
+        ax.tick_params(axis="both", which="both", bottom=False, top=False, left=False, right=False)
+        plt.setp(ax.spines.values(), visible=False)
     fig.tight_layout()
 
     # Display and return the image.
     image = convert_figure_to_image()
-    if not kwargs.get('no_show', False):
+    if not kwargs.get("no_show", False):
         display_image(image)
     return image
-
diff --git a/agml/viz/inspection.py b/agml/viz/inspection.py
index aebc98b7..3ea2e27e 100644
--- a/agml/viz/inspection.py
+++ b/agml/viz/inspection.py
@@ -12,22 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import glob
+import os
 
 import cv2
-
 import matplotlib.pyplot as plt
 from matplotlib.patches import FancyArrowPatch
 from mpl_toolkits.mplot3d import proj3d
 
-from agml.viz.labels import _inference_best_shape
 from agml.synthetic.tools import _is_agml_converted
 from agml.utils.image import imread_context
+from agml.viz.labels import _inference_best_shape
 
 
 class Arrow3D(FancyArrowPatch):
     """Draws a 3-dimensional arrow using the given coordinates."""
+
     def __init__(self, xs, ys, zs, *args, **kwargs):
         FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)
         self._coords = xs, ys, zs
@@ -64,20 +64,34 @@ def plot_synthetic_camera_positions(positions, lookat):
     The matplotlib figure with the plot.
     """
     # Creat ethe figure.
-    plt.figure(figsize = (7, 7))
-    ax = plt.axes(projection = '3d')
-    ax.plot3D(0, 0, 1, 'r*', label = 'Canopy Origin')
+    plt.figure(figsize=(7, 7))
+    ax = plt.axes(projection="3d")
+    ax.plot3D(0, 0, 1, "r*", label="Canopy Origin")
     for i in range(len(positions)):
-        ax.plot3D(positions[i][0], positions[i][1], positions[i][2], 'o',
-                  label = 'Camera ' + str(i))
-        arw = Arrow3D([positions[i][0], lookat[i][0]],
-                      [positions[i][1], lookat[i][1]],
-                      [positions[i][2], lookat[i][2]],
-                      arrowstyle = "->", color = "purple",
-                      lw = 1, mutation_scale = 25)
+        ax.plot3D(
+            positions[i][0],
+            positions[i][1],
+            positions[i][2],
+            "o",
+            label="Camera " + str(i),
+        )
+        arw = Arrow3D(
+            [positions[i][0], lookat[i][0]],
+            [positions[i][1], lookat[i][1]],
+            [positions[i][2], lookat[i][2]],
+            arrowstyle="->",
+            color="purple",
+            lw=1,
+            mutation_scale=25,
+        )
         ax.add_artist(arw)
-    ax.legend(loc = 'upper center', bbox_to_anchor = (0.5, 1.05),
-              ncol = 4, fancybox = True, shadow = True)
+    ax.legend(
+        loc="upper center",
+        bbox_to_anchor=(0.5, 1.05),
+        ncol=4,
+        fancybox=True,
+        shadow=True,
+    )
     fig = plt.gcf()
     return fig
 
@@ -108,23 +122,18 @@ def visualize_all_views(dataset_path, image):
     """
     dataset_path = os.path.abspath(os.path.expanduser(dataset_path))
     if not os.path.exists(dataset_path):
-        raise NotADirectoryError(
-            f"The provided dataset path {dataset_path} does not exist.")
+        raise NotADirectoryError(f"The provided dataset path {dataset_path} does not exist.")
 
     # Get all of the views for the input image.
     image = str(image)
-    if image.startswith('image'):
-        image = image.replace('image', '')
+    if image.startswith("image"):
+        image = image.replace("image", "")
     if _is_agml_converted(dataset_path):
-        views = glob.glob(os.path.join(
-            dataset_path, 'images', f'image{image}-view*.jpeg'))
+        views = glob.glob(os.path.join(dataset_path, "images", f"image{image}-view*.jpeg"))
         if len(views) == 0:
-            views = glob.glob(os.path.join(
-                dataset_path, f'image{image}-view*.jpeg'))
+            views = glob.glob(os.path.join(dataset_path, f"image{image}-view*.jpeg"))
     else:
-        views = glob.glob(os.path.join(
-            dataset_path, f'image{image}', '**/*.jpeg'
-        ), recursive = True)
+        views = glob.glob(os.path.join(dataset_path, f"image{image}", "**/*.jpeg"), recursive=True)
 
     # Check that there are images.
     if len(views) == 0:
@@ -138,7 +147,7 @@ def visualize_all_views(dataset_path, image):
 
     # Construct the figure.
     shape = _inference_best_shape(len(images))
-    fig, axes = plt.subplots(shape[0], shape[1], figsize = (shape[1] * 5, shape[0] * 5))
+    fig, axes = plt.subplots(shape[0], shape[1], figsize=(shape[1] * 5, shape[0] * 5))
     for image, ax in zip(images, axes.flat):
         ax.imshow(image)
         ax.set_axis_off()
@@ -146,6 +155,3 @@ def visualize_all_views(dataset_path, image):
     # Return the figure.
     fig.tight_layout()
     return fig
-
-
-
diff --git a/agml/viz/labels.py b/agml/viz/labels.py
index 029fceac..13588ef7 100644
--- a/agml/viz/labels.py
+++ b/agml/viz/labels.py
@@ -12,19 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import numpy as np
 import matplotlib.pyplot as plt
+import numpy as np
 
 from agml.backend.tftorch import as_scalar, is_array_like
-from agml.viz.tools import format_image, _inference_best_shape, convert_figure_to_image
 from agml.viz.display import display_image
+from agml.viz.tools import _inference_best_shape, convert_figure_to_image, format_image
 
 
-def show_images_and_labels(images,
-                           labels = None,
-                           info = None,
-                           shape = None,
-                           **kwargs):
+def show_images_and_labels(images, labels=None, info=None, shape=None, **kwargs):
     """Visualizes a set of images with their classification labels.
 
     Given a set of images and their corresponding labels, this method
@@ -57,13 +53,14 @@ def show_images_and_labels(images,
     The matplotlib figure with the plotted info.
     """
     if images is not None and labels is None:
-        if is_array_like(images[0], no_list = True):
+        if is_array_like(images[0], no_list=True):
             if images[0].ndim >= 3:
                 images, labels = images[0], images[1]
             else:
                 raise ValueError(
                     "If passing a numpy array for `images`, expected at "
-                    "least three dimensions: (batch, height, width).")
+                    "least three dimensions: (batch, height, width)."
+                )
         elif isinstance(images[0], (tuple, list)):
             if isinstance(images[0][0], np.ndarray):
                 if len(images[0]) == 2:
@@ -75,16 +72,15 @@ def show_images_and_labels(images,
                 else:
                     images, labels = images[0], images[1]
     if labels is None:
-        raise TypeError(
-            "Invalid format for `images` and `labels`, see documentation.")
+        raise TypeError("Invalid format for `images` and `labels`, see documentation.")
     if isinstance(images, np.ndarray) and images.shape[0] > 100:
         images, labels = [images], [labels]
 
     # Check if the labels are converted to one-hot, and re-convert them back.
     if is_array_like(labels):
         if not isinstance(labels, (list, tuple)):
-            if labels.ndim == 2: # noqa
-                labels = np.argmax(labels, axis = -1)
+            if labels.ndim == 2:  # noqa
+                labels = np.argmax(labels, axis=-1)
 
     # If a prime number is passed, e.g. 23, then the `_inference_best_shape`
     # method will return the shape of (23, 1). Likely, the user is expecting
@@ -94,14 +90,13 @@ def show_images_and_labels(images,
         shape = _inference_best_shape(len(images))
     if max(shape) > 20:
         raise NotImplementedError(
-            "Length of maximum shape length is greater than 20. "
-            "This method does not support non-rectangular shapes.")
+            "Length of maximum shape length is greater than 20. " "This method does not support non-rectangular shapes."
+        )
 
-    fig, axes = plt.subplots(
-        shape[0], shape[1], figsize = (shape[1] * 2, shape[0] * 2))
+    fig, axes = plt.subplots(shape[0], shape[1], figsize=(shape[1] * 2, shape[0] * 2))
     try:
         iter_ax = axes.flat
-    except AttributeError: # If showing only a single image.
+    except AttributeError:  # If showing only a single image.
         iter_ax = [axes]
     for image, label, ax in zip(images, labels, iter_ax):
         ax.imshow(format_image(image))
@@ -111,9 +106,8 @@ def show_images_and_labels(images,
             label = info.num_to_class[label]
         ax.set_xticklabels([])
         ax.set_yticklabels([])
-        ax.tick_params(axis = 'both', which = 'both', bottom = False,
-                       top = False, left = False, right = False)
-        plt.setp(ax.spines.values(), visible = False)
+        ax.tick_params(axis="both", which="both", bottom=False, top=False, left=False, right=False)
+        plt.setp(ax.spines.values(), visible=False)
         ax.set_xlabel(label)
 
         # decrease the label size (if it's too big)
@@ -122,10 +116,6 @@ def show_images_and_labels(images,
     # Display and return the image.
     fig.tight_layout()
     image = convert_figure_to_image()
-    if not kwargs.get('no_show', False):
+    if not kwargs.get("no_show", False):
         _ = display_image(image)
     return image
-
-
-
-
diff --git a/agml/viz/masks.py b/agml/viz/masks.py
index 48f3f490..46150a60 100644
--- a/agml/viz/masks.py
+++ b/agml/viz/masks.py
@@ -13,15 +13,15 @@
 # limitations under the License.
 
 import cv2
-import numpy as np
 import matplotlib.pyplot as plt
+import numpy as np
 
 from agml.utils.general import resolve_tuple_values
-from agml.viz.tools import get_colormap, format_image, convert_figure_to_image
 from agml.viz.display import display_image
+from agml.viz.tools import convert_figure_to_image, format_image, get_colormap
 
 
-def binary_to_channel_by_channel(mask, num_classes = None):
+def binary_to_channel_by_channel(mask, num_classes=None):
     """Converts a mask from 2-dimensional to channel-by-channel."""
     # If the mask is already 3 channels (in channel-by-channel format),
     # then don't do anything and return the original mask as-is.
@@ -36,10 +36,10 @@ def binary_to_channel_by_channel(mask, num_classes = None):
     input_shape = mask.shape
     mask = mask.ravel()
     n = mask.shape[0]
-    mask = np.array(mask, dtype = np.int32)
+    mask = np.array(mask, dtype=np.int32)
     if num_classes is None:
         num_classes = np.max(mask) + 1
-    out = np.zeros(shape = (n, num_classes))
+    out = np.zeros(shape=(n, num_classes))
     out[np.arange(n), mask] = 1
     out = np.reshape(out, input_shape + (num_classes,))
     return out[..., 1:].astype(np.int32)
@@ -63,23 +63,20 @@ def convert_mask_to_colored_image(mask):
     # convert it from a channel-by-channel mask to a 2-dimensional mask.
     if mask.ndim == 3:
         if not np.all(mask[:, :, 0] == mask[:, :, 1]):
-            mask = np.argmax(mask, axis = -1)
+            mask = np.argmax(mask, axis=-1)
     if mask.ndim == 2:
         mask = np.dstack((mask, mask, mask))
 
     # Add a colorscheme to the labels.
     cmap = get_colormap()
-    label_indices = np.unique(mask)[1:] # skip the background label
+    label_indices = np.unique(mask)[1:]  # skip the background label
     for label_indx in label_indices:
         x_values, y_values, *_ = np.where(mask == label_indx)
         mask[tuple([*np.stack([x_values, y_values])])] = cmap[label_indx]
     return mask
 
 
-def annotate_semantic_segmentation(image,
-                                   mask = None,
-                                   alpha = 0.3,
-                                   border = True):
+def annotate_semantic_segmentation(image, mask=None, alpha=0.3, border=True):
     """Annotates a semantic segmentation mask over an image.
 
     This method overlays a segmentation mask over an image. It uses contours
@@ -105,43 +102,37 @@ def annotate_semantic_segmentation(image,
     """
     # Get the image and mask from the given input arguments.
     image, mask = resolve_tuple_values(
-        image, mask, custom_error =
-        "If `image` is a tuple/list, it should contain "
-        "two values: the image and its mask.")
+        image,
+        mask,
+        custom_error="If `image` is a tuple/list, it should contain " "two values: the image and its mask.",
+    )
     image = format_image(image)
-    mask = binary_to_channel_by_channel(format_image(mask, mask = True))
+    mask = binary_to_channel_by_channel(format_image(mask, mask=True))
 
     # Plot the given segmentation mask over the image. This essentially
     # overlays the given mask using contours to draw out segmentation borders.
     cmap = get_colormap()
     mask = np.transpose(mask, (2, 0, 1))
     for level, label in enumerate(mask):
-        label = np.expand_dims(label, axis = -1)
-        label = (label * np.true_divide(255, np.max(label, axis = (0, 1)) + 1e-6)).astype(np.uint8)
+        label = np.expand_dims(label, axis=-1)
+        label = (label * np.true_divide(255, np.max(label, axis=(0, 1)) + 1e-6)).astype(np.uint8)
 
         # Find the given contours and plot them.
         _, thresh = cv2.threshold(label, 127, 255, cv2.THRESH_BINARY)
-        contours, _ = cv2.findContours(
-            thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
+        contours, _ = cv2.findContours(thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
         for indx, contour in enumerate(contours):
             color = cmap[level + 1]
             overlay = image.copy()
-            cv2.fillPoly(overlay, pts = [contour], color = color)
+            cv2.fillPoly(overlay, pts=[contour], color=color)
             image = cv2.addWeighted(overlay, alpha, image, 1 - alpha, 0)
 
             # Draws the actual contour borders to show the segmented blobs.
             if border:
-                image = cv2.polylines(
-                    image, pts = [contour], isClosed = True,
-                    color = color, thickness = 2)
+                image = cv2.polylines(image, pts=[contour], isClosed=True, color=color, thickness=2)
     return image
 
 
-def show_image_and_overlaid_mask(image,
-                                 mask = None,
-                                 alpha = 0.3,
-                                 border = True,
-                                 **kwargs):
+def show_image_and_overlaid_mask(image, mask=None, alpha=0.3, border=True, **kwargs):
     """Displays an image with an annotated segmentation mask.
 
     This method overlays a segmentation mask over an image. It uses contours
@@ -166,20 +157,15 @@ def show_image_and_overlaid_mask(image,
     The annotated image.
     """
     # Parse the inputs and annotate the image.
-    image = annotate_semantic_segmentation(image = image,
-                                           mask = mask,
-                                           alpha = alpha,
-                                           border = border)
+    image = annotate_semantic_segmentation(image=image, mask=mask, alpha=alpha, border=border)
 
     # Display the annotated image.
-    if not kwargs.get('no_show', False):
-        _ = display_image(image, matplotlib_figure = False)
+    if not kwargs.get("no_show", False):
+        _ = display_image(image, matplotlib_figure=False)
     return image
 
 
-def show_image_and_mask(image,
-                        mask = None,
-                        **kwargs):
+def show_image_and_mask(image, mask=None, **kwargs):
     """Displays an image and its mask side-by-side.
 
     This method displays an image and its mask side-by-side. Note that if you
@@ -201,67 +187,59 @@ def show_image_and_mask(image,
     """
     # Get the image and mask from the given input arguments.
     image, mask = resolve_tuple_values(
-        image, mask, custom_error =
-        "If `image` is a tuple/list, it should contain "
-        "two values: the image and its mask.")
+        image,
+        mask,
+        custom_error="If `image` is a tuple/list, it should contain " "two values: the image and its mask.",
+    )
 
     # Prepare the inputs.
     image = format_image(image)
-    mask = convert_mask_to_colored_image(format_image(mask, mask = True))
+    mask = convert_mask_to_colored_image(format_image(mask, mask=True))
 
     # Display the image and its mask side-by-side.
-    fig, axes = plt.subplots(1, 2, figsize = (12, 6))
+    fig, axes = plt.subplots(1, 2, figsize=(12, 6))
     axes[0].imshow(image)
     axes[1].imshow(mask)
     for ax in axes:
-        ax.set_aspect('equal')
-        ax.axis('off')
+        ax.set_aspect("equal")
+        ax.axis("off")
     plt.tight_layout()
 
     # Display and return the image.
     image = convert_figure_to_image()
-    if not kwargs.get('no_show', False):
+    if not kwargs.get("no_show", False):
         _ = display_image(image)
     return image
 
 
-def show_semantic_segmentation_truth_and_prediction(image,
-                                                    real_mask = None,
-                                                    predicted_mask = None,
-                                                    alpha = 0.3,
-                                                    border = True,
-                                                    **kwargs):
+def show_semantic_segmentation_truth_and_prediction(
+    image, real_mask=None, predicted_mask=None, alpha=0.3, border=True, **kwargs
+):
     # Parse the input arguments to get the corresponding images
     # and masks stored in the correct variables.
     image, real_mask, predicted_mask = resolve_tuple_values(
-        image, real_mask, predicted_mask, custom_error =
-        "If `image` is a tuple/list, it should contain "
-        "three values: the image, the real mask, and the predicted mask.")
+        image,
+        real_mask,
+        predicted_mask,
+        custom_error="If `image` is a tuple/list, it should contain "
+        "three values: the image, the real mask, and the predicted mask.",
+    )
 
     # Generate the real and predicted images with their segmentation masks.
-    real_image = annotate_semantic_segmentation(image = image,
-                                                mask = real_mask,
-                                                alpha = alpha,
-                                                border = border)
-    predicted_image = annotate_semantic_segmentation(image = image,
-                                                     mask = predicted_mask,
-                                                     alpha = alpha,
-                                                     border = border)
+    real_image = annotate_semantic_segmentation(image=image, mask=real_mask, alpha=alpha, border=border)
+    predicted_image = annotate_semantic_segmentation(image=image, mask=predicted_mask, alpha=alpha, border=border)
 
     # Create two side-by-side figures with the images.
-    fig, axes = plt.subplots(1, 2, figsize = (12, 6))
-    for ax, img, label in zip(
-            axes, (real_image, predicted_image),
-            ("Ground Truth Mask", "Predicted Mask")):
+    fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+    for ax, img, label in zip(axes, (real_image, predicted_image), ("Ground Truth Mask", "Predicted Mask")):
         ax.imshow(img)
         ax.set_axis_off()
-        ax.set_title(label, fontsize = 15)
-        ax.set_aspect('equal')
+        ax.set_title(label, fontsize=15)
+        ax.set_aspect("equal")
     fig.tight_layout()
 
     # Display and return the image.
     image = convert_figure_to_image()
-    if not kwargs.get('no_show', False):
+    if not kwargs.get("no_show", False):
         _ = display_image(image)
     return image
-
diff --git a/agml/viz/point_clouds.py b/agml/viz/point_clouds.py
index 4d3bee79..b933f038 100644
--- a/agml/viz/point_clouds.py
+++ b/agml/viz/point_clouds.py
@@ -12,15 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import numpy as np
-
 import matplotlib.pyplot as plt
+import numpy as np
 
 from agml.data.point_cloud import PointCloud
 from agml.utils.logging import log
 
 
-def show_point_cloud(point_cloud, format = 'default'):
+def show_point_cloud(point_cloud, format="default"):
     """Visualizes a point cloud in 3-dimensional space.
 
     Parameters
@@ -37,29 +36,27 @@ def show_point_cloud(point_cloud, format = 'default'):
     try:
         import open3d as o3d
     except:
-        log("Open3D is not installed. If you want to have high-res point cloud "
+        log(
+            "Open3D is not installed. If you want to have high-res point cloud "
             "visualizations, please install Open3D using `pip install open3d`. "
-            "For now, defaulting to using 3D matplotlib visualizations.")
+            "For now, defaulting to using 3D matplotlib visualizations."
+        )
         o3d = None
 
     # We need to hard-code this check because this method isn't designed to
     # run with regular point cloud arrays, only `point_cloud` objects.
     if not isinstance(point_cloud, PointCloud):
-        raise TypeError(f'`point_cloud` must be a `PointCloud` object, instead got {point_cloud}.')
+        raise TypeError(f"`point_cloud` must be a `PointCloud` object, instead got {point_cloud}.")
 
     # If Open3D is installed, we can just use that.
-    if o3d is not None and format in ['open3d', 'default']:
+    if o3d is not None and format in ["open3d", "default"]:
         o3d.visualization.draw_geometries([point_cloud.structure_3d])
         return
 
     # Otherwise, use matplotlib to plot the points.
     coords = point_cloud._coordinates
-    x, y, z = np.rollaxis(coords, axis = 1)
-    fig = plt.figure(figsize = (16, 16))
-    ax = fig.add_subplot(111, projection = '3d')
-    ax.scatter(x, y, z, c = point_cloud.labels)
+    x, y, z = np.rollaxis(coords, axis=1)
+    fig = plt.figure(figsize=(16, 16))
+    ax = fig.add_subplot(111, projection="3d")
+    ax.scatter(x, y, z, c=point_cloud.labels)
     plt.show()
-
-
-
-
diff --git a/agml/viz/tools.py b/agml/viz/tools.py
index 4e2a4f57..3d76ac01 100644
--- a/agml/viz/tools.py
+++ b/agml/viz/tools.py
@@ -17,42 +17,46 @@
 mini-backend to control ops such as the colormap being used.
 """
 
-import os
+import functools
 import io
 import json
-import functools
+import os
 
 import cv2
+import matplotlib.pyplot as plt
 import numpy as np
 from PIL import Image
-import matplotlib.pyplot as plt
 
-from agml.backend.tftorch import tf, torch
 from agml.backend.config import _get_config, _update_config
+from agml.backend.tftorch import tf, torch
 from agml.utils.logging import log
 
 
 # Sets the colormaps used in the other `agml.viz` methods.
-@functools.lru_cache(maxsize = None)
+@functools.lru_cache(maxsize=None)
 def _load_colormaps():
-    with open(os.path.join(os.path.dirname(os.path.dirname(__file__)),
-                           '_assets', 'viz_colormaps.json'), 'r') as f:
+    with open(
+        os.path.join(os.path.dirname(os.path.dirname(__file__)), "_assets", "viz_colormaps.json"),
+        "r",
+    ) as f:
         cmaps = json.load(f)
     ret_dict = {}
     for map_ in cmaps.items():
         ret_dict[map_[0]] = map_[1] * 5
     return ret_dict
 
+
 _COLORMAPS = _load_colormaps()
-_COLORMAP_CHOICE: str = 'default'
+_COLORMAP_CHOICE: str = "default"
 
 
 # Sets the visualization backend: either `matplotlib` or `cv2`.
-@functools.lru_cache(maxsize = None)
+@functools.lru_cache(maxsize=None)
 def _load_backend():
-    if _get_config('viz_backend') is None:
-        _update_config('viz_backend', 'matplotlib')
-    return _get_config('viz_backend')
+    if _get_config("viz_backend") is None:
+        _update_config("viz_backend", "matplotlib")
+    return _get_config("viz_backend")
+
 
 _BACKEND: str = _load_backend()
 
@@ -84,16 +88,15 @@ def set_colormap(colormap):
     global _COLORMAP_CHOICE, _COLORMAPS
     if isinstance(colormap, list):
         if not all(len(i) == 3 for i in colormap):
-            raise ValueError(
-                "If you want a custom colormap, then pass a list of RGB values.")
+            raise ValueError("If you want a custom colormap, then pass a list of RGB values.")
     elif isinstance(colormap, str):
         colormap = colormap.lower()
         if colormap not in _COLORMAPS.keys():
             raise ValueError(f"Invalid colormap {colormap} received.")
     else:
         raise TypeError(f"Invalid colormap of type {type(colormap)}.")
-    _COLORMAPS['custom'] = colormap
-    _COLORMAP_CHOICE = 'custom'
+    _COLORMAPS["custom"] = colormap
+    _COLORMAP_CHOICE = "custom"
 
 
 def get_viz_backend():
@@ -104,14 +107,14 @@ def get_viz_backend():
 
 def set_viz_backend(backend):
     """Sets the global AgML visualization backend."""
-    if backend not in ['matplotlib', 'cv2']:
+    if backend not in ["matplotlib", "cv2"]:
         raise ValueError(f"Invalid backend {backend} received.")
     global _BACKEND
-    _update_config('viz_backend', backend)
+    _update_config("viz_backend", backend)
     _BACKEND = backend
 
 
-def format_image(img, mask = False):
+def format_image(img, mask=False):
     """Formats an image to be used in a Matplotlib visualization.
 
     This method takes in one of a number of common image/array types
@@ -146,16 +149,14 @@ def format_image(img, mask = False):
     elif isinstance(img, tf.Tensor):
         img = img.numpy()
     else:
-        raise TypeError(
-            f"Expected either an np.ndarray, torch.Tensor, "
-            f"tf.Tensor, or PIL.Image, got {type(img)}.")
+        raise TypeError(f"Expected either an np.ndarray, torch.Tensor, " f"tf.Tensor, or PIL.Image, got {type(img)}.")
 
     # Convert channels_first to channels_last.
     if img.ndim == 4:
         if img.shape[0] > 1:
             raise ValueError(
-                f"Got a batch of images with shape {img.shape}, "
-                f"expected at most a batch of one image.")
+                f"Got a batch of images with shape {img.shape}, " f"expected at most a batch of one image."
+            )
         img = np.squeeze(img)
     if img.shape[0] <= 3:
         img = np.transpose(img, (1, 2, 0))
@@ -170,29 +171,31 @@ def format_image(img, mask = False):
         img = img.astype(np.uint8)
     else:
         if np.issubdtype(img.dtype, np.inexact):
-            if not img.max() <= 1: # noqa
+            if not img.max() <= 1:  # noqa
                 img = img.astype(np.uint8)
             else:
                 img = (img * 255).astype(np.uint8)
 
         # Convert 64-bit integer to unsigned 8-bit.
         if img.dtype == np.int64:
-            log("Converting image of dtype `np.int64` to `np.uint8` for display. "
-                "This may cause a loss in precision/invalid result.")
+            log(
+                "Converting image of dtype `np.int64` to `np.uint8` for display. "
+                "This may cause a loss in precision/invalid result."
+            )
             img = img.astype(np.uint8)
 
     # Return the formatted image.
     return np.ascontiguousarray(img)
 
 
-def convert_figure_to_image(fig = None):
+def convert_figure_to_image(fig=None):
     """This method is used to convert a Matplotlib figure to an image array."""
     # Use PIL to get the image, then convert to an array.
     buf = io.BytesIO()
     fig = fig if fig is not None else plt.gcf()
-    fig.savefig(buf, format = 'png')
+    fig.savefig(buf, format="png")
     buf.seek(0)
-    arr = np.fromstring(buf.read(), dtype = np.uint8)
+    arr = np.fromstring(buf.read(), dtype=np.uint8)
     return cv2.imdecode(arr, cv2.IMREAD_COLOR)
 
 
diff --git a/config/coverage.ini b/config/coverage.ini
new file mode 100644
index 00000000..cc11b417
--- /dev/null
+++ b/config/coverage.ini
@@ -0,0 +1,49 @@
+[coverage:paths]
+source =
+  agml/
+
+[coverage:run]
+branch = true
+source =
+  agml
+  tests
+parallel = true
+data_file =  .coverage
+
+[coverage:report]
+precision = 2
+omit =
+
+  tests/*
+  */__init__.py
+  */_version.py
+  /private/*
+  /tmp/*
+
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if self\.debug
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if __name__ == .__main__.:
+
+    # Don't complain about abstract methods, they aren't run:
+    @(abc\.)?abstractmethod
+
+[coverage:html]
+directory = site/coverage
+
+[coverage:json]
+output = coverage.json
+
+[coverage:xml]
+output = coverage.xml
diff --git a/config/interrogate.toml b/config/interrogate.toml
new file mode 100644
index 00000000..7465152f
--- /dev/null
+++ b/config/interrogate.toml
@@ -0,0 +1,22 @@
+[tool.interrogate]
+ignore-init-method = true
+ignore-init-module = true
+ignore-magic = false
+ignore-semiprivate = false
+ignore-private = false
+ignore-property-decorators = false
+ignore-module = true
+ignore-nested-functions = false
+ignore-nested-classes = true
+ignore-setters = false
+fail-under = 40
+exclude = ["setup.py", "docs", "build"]
+ignore-regex = ["^get$", "^mock_.*", ".*BaseClass.*"]
+# possible values: 0 (minimal output), 1 (-v), 2 (-vv)
+verbose = 3
+quiet = false
+whitelist-regex = []
+color = true
+omit-covered-files = false
+generate-badge = "interrogate_badge.svg"
+badge-format = "svg"
diff --git a/config/mypy.ini b/config/mypy.ini
new file mode 100644
index 00000000..1360efa7
--- /dev/null
+++ b/config/mypy.ini
@@ -0,0 +1,9 @@
+[mypy]
+files= *.py
+ignore_missing_imports = True
+disallow_untyped_defs = True
+strict = True
+pretty = True
+color_output = True
+implicit_reexport = False
+linecount-report =True
diff --git a/config/pytest.ini b/config/pytest.ini
new file mode 100644
index 00000000..47faa5cc
--- /dev/null
+++ b/config/pytest.ini
@@ -0,0 +1,15 @@
+[pytest]
+norecursedirs =
+  .git
+  .tox
+  .env
+  dist
+  build
+  tests/.ipynb_checkpoints
+  tests/*/.ipynb_checkpoints
+  tests/*
+python_files =
+  test_*.py main.py
+testpaths =
+  ./tests/*
+addopts = -v  --cov-config=./config/coverage.ini --cov=./agml --cov-report=xml --cov-report=html --cov-report=term-missing
diff --git a/config/ruff.toml b/config/ruff.toml
new file mode 100644
index 00000000..ef38ac6d
--- /dev/null
+++ b/config/ruff.toml
@@ -0,0 +1,94 @@
+
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+
+line-length = 120
+indent-width = 4
+
+# Assume Python 3.8
+target-version = "py38"
+
+[lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "F"]
+ignore = []
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"
+
+[lint.isort]
+
+case-sensitive = true
+default-section = "third-party"
+known-first-party = ["agml"]
+split-on-trailing-comma = false
+section-order = [
+  "future",
+  "standard-library",
+  "third-party",
+  "first-party",
+  "local-folder",
+]
+from-first = false
\ No newline at end of file
diff --git a/examples/AgML-Data.ipynb b/examples/AgML-Data.ipynb
index 1e40afac..3879d0a4 100644
--- a/examples/AgML-Data.ipynb
+++ b/examples/AgML-Data.ipynb
@@ -46,11 +46,12 @@
    },
    "outputs": [],
    "source": [
-    "import agml\n",
-    "import agml.viz as viz\n",
+    "from pprint import pprint\n",
     "\n",
     "import numpy as np\n",
-    "from pprint import pprint\n",
+    "\n",
+    "import agml\n",
+    "import agml.viz as viz\n",
     "\n",
     "%matplotlib inline\n",
     "%load_ext autoreload\n",
@@ -167,7 +168,9 @@
    ],
    "source": [
     "# Filter datasets by their number of images and deep learning task.\n",
-    "pprint(agml.data.public_data_sources(ml_task = 'object_detection', location='country:usa'))"
+    "pprint(\n",
+    "    agml.data.public_data_sources(ml_task=\"object_detection\", location=\"country:usa\")\n",
+    ")"
    ]
   },
   {
@@ -253,7 +256,7 @@
     }
    ],
    "source": [
-    "loader = agml.data.AgMLDataLoader('bean_disease_uganda')\n",
+    "loader = agml.data.AgMLDataLoader(\"bean_disease_uganda\")\n",
     "loader.info.summary()"
    ]
   },
@@ -280,12 +283,16 @@
    "source": [
     "# Mount Google Drive into Colab\n",
     "import sys\n",
-    "if 'google.colab' in sys.modules:\n",
+    "\n",
+    "if \"google.colab\" in sys.modules:\n",
     "    from google.colab import drive\n",
-    "    drive.mount('/content/drive')\n",
+    "\n",
+    "    drive.mount(\"/content/drive\")\n",
     "\n",
     "    # Load the dataset into Google Drive\n",
-    "    loader = agml.data.AgMLDataLoader('bean_disease_uganda' , dataset_path = '/content/drive/MyDrive/AgMLData/')"
+    "    loader = agml.data.AgMLDataLoader(\n",
+    "        \"bean_disease_uganda\", dataset_path=\"/content/drive/MyDrive/AgMLData/\"\n",
+    "    )"
    ]
   },
   {
@@ -459,7 +466,7 @@
     "# Un-batch the data for splitting.\n",
     "loader.batch(None)\n",
     "\n",
-    "loader.split(train = 0.7, val = 0.2, test = 0.1)\n",
+    "loader.split(train=0.7, val=0.2, test=0.1)\n",
     "train, val, test = loader.train_data, loader.val_data, loader.test_data\n",
     "print(\n",
     "    f\"Total Length:\\t {len(loader)}\\n\"\n",
@@ -561,7 +568,7 @@
     }
    ],
    "source": [
-    "loader = agml.data.AgMLDataLoader('apple_flower_segmentation')\n",
+    "loader = agml.data.AgMLDataLoader(\"apple_flower_segmentation\")\n",
     "loader.info.summary()"
    ]
   },
@@ -648,8 +655,8 @@
     "loader.batch(8)\n",
     "images, annotations = loader[0]\n",
     "for image, annotation in zip(images[:2], annotations[:2]):\n",
-    "  image, annotation = np.squeeze(image), np.squeeze(annotation)\n",
-    "  _ = viz.show_image_and_mask(image, annotation)"
+    "    image, annotation = np.squeeze(image), np.squeeze(annotation)\n",
+    "    _ = viz.show_image_and_mask(image, annotation)"
    ]
   },
   {
@@ -717,7 +724,7 @@
     }
    ],
    "source": [
-    "loader = agml.data.AgMLDataLoader('fruit_detection_worldwide')\n",
+    "loader = agml.data.AgMLDataLoader(\"fruit_detection_worldwide\")\n",
     "loader.info.summary()"
    ]
   },
@@ -841,10 +848,8 @@
    "source": [
     "import albumentations as A\n",
     "\n",
-    "loader = agml.data.AgMLDataLoader('bean_disease_uganda')\n",
-    "loader.transform(\n",
-    "    transform = A.Compose([A.HorizontalFlip(), A.RandomRotate90()])\n",
-    ")"
+    "loader = agml.data.AgMLDataLoader(\"bean_disease_uganda\")\n",
+    "loader.transform(transform=A.Compose([A.HorizontalFlip(), A.RandomRotate90()]))"
    ]
   },
   {
@@ -882,8 +887,9 @@
    "source": [
     "transformed_images, labels = [], []\n",
     "for _ in range(10):\n",
-    "  image, label = loader[0]\n",
-    "  transformed_images.append(image); labels.append(label)\n",
+    "    image, label = loader[0]\n",
+    "    transformed_images.append(image)\n",
+    "    labels.append(label)\n",
     "\n",
     "_ = viz.show_images_and_labels(transformed_images, labels)"
    ]
@@ -905,13 +911,11 @@
    },
    "outputs": [],
    "source": [
-    "from tensorflow.keras.models import Sequential\n",
     "from tensorflow.keras.layers import RandomFlip, RandomRotation\n",
+    "from tensorflow.keras.models import Sequential\n",
     "\n",
-    "loader.transform(transform='reset')\n",
-    "loader.transform(\n",
-    "    transform=Sequential([RandomFlip(), RandomRotation(0.2)])\n",
-    ")"
+    "loader.transform(transform=\"reset\")\n",
+    "loader.transform(transform=Sequential([RandomFlip(), RandomRotation(0.2)]))"
    ]
   },
   {
@@ -951,8 +955,9 @@
    "source": [
     "transformed_images, labels = [], []\n",
     "for _ in range(10):\n",
-    "  image, label = loader[0]\n",
-    "  transformed_images.append(image); labels.append(label)\n",
+    "    image, label = loader[0]\n",
+    "    transformed_images.append(image)\n",
+    "    labels.append(label)\n",
     "\n",
     "_ = viz.show_images_and_labels(transformed_images, labels, info=loader.info)"
    ]
@@ -993,13 +998,16 @@
     "import tensorflow as tf\n",
     "\n",
     "loader.transform(\n",
-    "    transform = lambda image: tf.image.random_flip_up_down(tf.image.random_saturation(image, 1, 10))\n",
+    "    transform=lambda image: tf.image.random_flip_up_down(\n",
+    "        tf.image.random_saturation(image, 1, 10)\n",
+    "    )\n",
     ")\n",
     "\n",
     "transformed_images, labels = [], []\n",
     "for _ in range(10):\n",
-    "  image, label = loader[0]\n",
-    "  transformed_images.append(image); labels.append(label)\n",
+    "    image, label = loader[0]\n",
+    "    transformed_images.append(image)\n",
+    "    labels.append(label)\n",
     "\n",
     "_ = viz.show_images_and_labels(transformed_images, labels, info=loader.info)"
    ]
@@ -1029,15 +1037,13 @@
    "outputs": [],
    "source": [
     "# Switch the backend back to torch.\n",
-    "agml.backend.set_backend('torch')\n",
+    "agml.backend.set_backend(\"torch\")\n",
     "\n",
-    "loader = agml.data.AgMLDataLoader('apple_flower_segmentation')\n",
-    "loader.transform(\n",
-    "    dual_transform = A.Compose([A.RandomRotate90(), A.HorizontalFlip()])\n",
-    ")\n",
+    "loader = agml.data.AgMLDataLoader(\"apple_flower_segmentation\")\n",
+    "loader.transform(dual_transform=A.Compose([A.RandomRotate90(), A.HorizontalFlip()]))\n",
     "\n",
     "for _ in range(4):\n",
-    "  _ = viz.show_image_and_overlaid_mask(loader[0])"
+    "    _ = viz.show_image_and_overlaid_mask(loader[0])"
    ]
   },
   {
@@ -1104,12 +1110,12 @@
    ],
    "source": [
     "loader.transform(\n",
-    "    transform = A.RandomBrightnessContrast(),\n",
-    "    dual_transform = A.Compose([A.RandomRotate90(), A.HorizontalFlip()])\n",
+    "    transform=A.RandomBrightnessContrast(),\n",
+    "    dual_transform=A.Compose([A.RandomRotate90(), A.HorizontalFlip()]),\n",
     ")\n",
     "\n",
     "for _ in range(4):\n",
-    "  _ = viz.show_image_and_mask(loader[0])"
+    "    _ = viz.show_image_and_mask(loader[0])"
    ]
   },
   {
@@ -1157,7 +1163,7 @@
    "source": [
     "import torch.utils.data\n",
     "\n",
-    "loader = agml.data.AgMLDataLoader('apple_flower_segmentation')\n",
+    "loader = agml.data.AgMLDataLoader(\"apple_flower_segmentation\")\n",
     "print(f\"Is PyTorch Dataset: {isinstance(loader, torch.utils.data.Dataset)}\")\n",
     "loader.as_torch_dataset()\n",
     "print(f\"Is PyTorch Dataset: {isinstance(loader, torch.utils.data.Dataset)}\")"
@@ -1186,8 +1192,8 @@
    "source": [
     "import tensorflow as tf\n",
     "\n",
-    "agml.backend.set_backend('tf')\n",
-    "loader = agml.data.AgMLDataLoader('apple_flower_segmentation')\n",
+    "agml.backend.set_backend(\"tf\")\n",
+    "loader = agml.data.AgMLDataLoader(\"apple_flower_segmentation\")\n",
     "print(f\"Is Keras Sequence: {isinstance(loader, tf.keras.utils.Sequence)}\")\n",
     "loader.as_keras_sequence()\n",
     "print(f\"Is Keras Sequence: {isinstance(loader, tf.keras.utils.Sequence)}\")"
@@ -1245,10 +1251,10 @@
     }
    ],
    "source": [
-    "classification_loader = agml.data.AgMLDataLoader('bean_disease_uganda')\n",
+    "classification_loader = agml.data.AgMLDataLoader(\"bean_disease_uganda\")\n",
     "contents = [[k, v] for k, v in classification_loader.export_contents().items()]\n",
     "for i in range(10):\n",
-    "  print(\"Image: {}\\n\\tLabel: {}\".format(contents[i][0], contents[i][1]))"
+    "    print(\"Image: {}\\n\\tLabel: {}\".format(contents[i][0], contents[i][1]))"
    ]
   },
   {
@@ -1299,7 +1305,7 @@
     }
    ],
    "source": [
-    "segmentation_loader = agml.data.AgMLDataLoader('apple_flower_segmentation')\n",
+    "segmentation_loader = agml.data.AgMLDataLoader(\"apple_flower_segmentation\")\n",
     "contents = [[k, v] for k, v in segmentation_loader.export_contents().items()]\n",
     "for i in range(10):\n",
     "    print(\"Image: {}\\n\\tAnnotation: {}\".format(contents[i][0], contents[i][1]))"
@@ -1344,10 +1350,10 @@
     }
    ],
    "source": [
-    "detection_loader = agml.data.AgMLDataLoader('fruit_detection_worldwide')\n",
+    "detection_loader = agml.data.AgMLDataLoader(\"fruit_detection_worldwide\")\n",
     "contents = detection_loader.export_contents()\n",
     "for image, annotation in list(contents.items())[:5]:\n",
-    "  print(\"Image: {}\\n\\tAnnotation: {}\".format(image, annotation))"
+    "    print(\"Image: {}\\n\\tAnnotation: {}\".format(image, annotation))"
    ]
   },
   {
@@ -1390,12 +1396,16 @@
    "source": [
     "import os\n",
     "\n",
-    "if 'google.colab' in sys.modules:\n",
-    "    agml.data.download_public_dataset('rice_seedling_segmentation', '/content/rice_seedling_segmentation')\n",
-    "    print(\"Directory Contents: \" + str(os.listdir('/content/rice_seedling_segmentation')))\n",
+    "if \"google.colab\" in sys.modules:\n",
+    "    agml.data.download_public_dataset(\n",
+    "        \"rice_seedling_segmentation\", \"/content/rice_seedling_segmentation\"\n",
+    "    )\n",
+    "    print(\n",
+    "        \"Directory Contents: \" + str(os.listdir(\"/content/rice_seedling_segmentation\"))\n",
+    "    )\n",
     "else:\n",
-    "    agml.data.download_public_dataset('rice_seedling_segmentation', '.')\n",
-    "    print(\"Directory Contents: \" + str(os.listdir('./rice_seedling_segmentation')))"
+    "    agml.data.download_public_dataset(\"rice_seedling_segmentation\", \".\")\n",
+    "    print(\"Directory Contents: \" + str(os.listdir(\"./rice_seedling_segmentation\")))"
    ]
   },
   {
@@ -1440,7 +1450,7 @@
     }
    ],
    "source": [
-    "loader = agml.data.AgMLDataLoader('apple_detection_spain')\n",
+    "loader = agml.data.AgMLDataLoader(\"apple_detection_spain\")\n",
     "print(agml.data.coco_to_bboxes(loader[0][1]))"
    ]
   },
@@ -1478,7 +1488,7 @@
     "bbox = [100, 200, 500, 700]\n",
     "\n",
     "# We can convert this to the correct format using the `fmt` argument.\n",
-    "print(agml.data.convert_bbox_format(bbox, ['x_min', 'y_min', 'x_max', 'y_max']))"
+    "print(agml.data.convert_bbox_format(bbox, [\"x_min\", \"y_min\", \"x_max\", \"y_max\"]))"
    ]
   },
   {
diff --git a/examples/AgML-Detector.ipynb b/examples/AgML-Detector.ipynb
index 57ec9f42..14368838 100644
--- a/examples/AgML-Detector.ipynb
+++ b/examples/AgML-Detector.ipynb
@@ -1,2034 +1,2033 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "id": "b8a968d2-80e4-41b0-b64c-1b8bfd3c4909",
-      "metadata": {
-        "ExecuteTime": {
-          "end_time": "2024-10-27T18:35:33.743370Z",
-          "start_time": "2024-10-27T18:35:33.705301Z"
-        },
-        "collapsed": true,
-        "jupyter": {
-          "outputs_hidden": true
-        },
-        "id": "b8a968d2-80e4-41b0-b64c-1b8bfd3c4909"
-      },
-      "source": [
-        "# AgML Detector\n",
-        "\n",
-        "The `agml.models.Detector` module is a sub-module of the `agml.models` module that is designed for quick and efficient object detection in an easy-to-use interface. If you want more customized control over your models, check out `agml.models.DetectionModel` instead. However, if you're just looking to quickly train a model and use it to run inference, the `agml.models.Detector` is right for you.\n",
-        "\n",
-        "THe `agml.models.Detector` wraps a YOLO11 model from [Ultralytics](https://github.com/ultralytics/ultralytics), and lets the underlying package abstract away most of the actual training/inference details, letting you focus on easy use of the API."
-      ]
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b8a968d2-80e4-41b0-b64c-1b8bfd3c4909",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-27T18:35:33.743370Z",
+     "start_time": "2024-10-27T18:35:33.705301Z"
+    },
+    "collapsed": true,
+    "id": "b8a968d2-80e4-41b0-b64c-1b8bfd3c4909",
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "source": [
+    "# AgML Detector\n",
+    "\n",
+    "The `agml.models.Detector` module is a sub-module of the `agml.models` module that is designed for quick and efficient object detection in an easy-to-use interface. If you want more customized control over your models, check out `agml.models.DetectionModel` instead. However, if you're just looking to quickly train a model and use it to run inference, the `agml.models.Detector` is right for you.\n",
+    "\n",
+    "THe `agml.models.Detector` wraps a YOLO11 model from [Ultralytics](https://github.com/ultralytics/ultralytics), and lets the underlying package abstract away most of the actual training/inference details, letting you focus on easy use of the API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2948f48816eb9fd1",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
     },
+    "id": "2948f48816eb9fd1",
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "outputId": "6a271834-a73b-466e-8e27-d42b11da59d0"
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": 1,
-      "id": "2948f48816eb9fd1",
-      "metadata": {
-        "jupyter": {
-          "outputs_hidden": false
-        },
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "2948f48816eb9fd1",
-        "outputId": "6a271834-a73b-466e-8e27-d42b11da59d0"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/382.7 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m378.9/382.7 kB\u001b[0m \u001b[31m15.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m382.7/382.7 kB\u001b[0m \u001b[31m7.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25h"
-          ]
-        }
-      ],
-      "source": [
-        "!pip install -q agml"
-      ]
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/382.7 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m378.9/382.7 kB\u001b[0m \u001b[31m15.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m382.7/382.7 kB\u001b[0m \u001b[31m7.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install -q agml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "qsqASPLsTPhA",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
     },
+    "id": "qsqASPLsTPhA",
+    "outputId": "1160c749-c2a9-420a-c5ea-054879be86c8"
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "source": [
-        "!pip install -q pytorch-lightning ensemble-boxes effdet==0.2.4"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "qsqASPLsTPhA",
-        "outputId": "1160c749-c2a9-420a-c5ea-054879be86c8"
-      },
-      "id": "qsqASPLsTPhA",
-      "execution_count": 2,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/117.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m117.0/117.0 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m111.2/111.2 kB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m815.2/815.2 kB\u001b[0m \u001b[31m13.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.5/79.5 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m890.6/890.6 kB\u001b[0m \u001b[31m20.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25h  Building wheel for antlr4-python3-runtime (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
-          ]
-        }
-      ]
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/117.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m117.0/117.0 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m111.2/111.2 kB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m815.2/815.2 kB\u001b[0m \u001b[31m13.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.5/79.5 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m890.6/890.6 kB\u001b[0m \u001b[31m20.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Building wheel for antlr4-python3-runtime (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install -q pytorch-lightning ensemble-boxes effdet==0.2.4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4G_HCbYcUlSd",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
     },
+    "id": "4G_HCbYcUlSd",
+    "outputId": "96091159-a6a3-4358-d249-d42cf7f985af"
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "source": [
-        "!pip install -q ultralytics"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "4G_HCbYcUlSd",
-        "outputId": "96091159-a6a3-4358-d249-d42cf7f985af"
-      },
-      "id": "4G_HCbYcUlSd",
-      "execution_count": 3,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/877.6 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m870.4/877.6 kB\u001b[0m \u001b[31m55.8 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m877.6/877.6 kB\u001b[0m \u001b[31m15.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25h"
-          ]
-        }
-      ]
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/877.6 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m870.4/877.6 kB\u001b[0m \u001b[31m55.8 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m877.6/877.6 kB\u001b[0m \u001b[31m15.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install -q ultralytics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1a4cb7be-042a-4383-ba6b-c44e1d3e541e",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
     },
+    "id": "1a4cb7be-042a-4383-ba6b-c44e1d3e541e",
+    "outputId": "bfe0a9c3-016d-4027-90d5-e252c0de3980"
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": 4,
-      "id": "1a4cb7be-042a-4383-ba6b-c44e1d3e541e",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "1a4cb7be-042a-4383-ba6b-c44e1d3e541e",
-        "outputId": "bfe0a9c3-016d-4027-90d5-e252c0de3980"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "/usr/local/lib/python3.10/dist-packages/albumentations/__init__.py:13: UserWarning: A new version of Albumentations is available: 1.4.20 (you have 1.4.15). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.\n",
-            "  check_for_updates()\n",
-            "/usr/local/lib/python3.10/dist-packages/timm/models/layers/__init__.py:48: FutureWarning: Importing from timm.models.layers is deprecated, please import via timm.layers\n",
-            "  warnings.warn(f\"Importing from {__name__} is deprecated, please import via timm.layers\", FutureWarning)\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Creating new Ultralytics Settings v0.0.6 file ✅ \n",
-            "View Ultralytics Settings with 'yolo settings' or at '/root/.config/Ultralytics/settings.json'\n",
-            "Update Settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'. For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings.\n"
-          ]
-        }
-      ],
-      "source": [
-        "import agml\n",
-        "import agml.models\n",
-        "\n",
-        "from PIL import Image\n",
-        "import matplotlib.pyplot as plt\n",
-        "\n",
-        "%matplotlib inline\n",
-        "%load_ext autoreload\n",
-        "%autoreload 2"
-      ]
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/albumentations/__init__.py:13: UserWarning: A new version of Albumentations is available: 1.4.20 (you have 1.4.15). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.\n",
+      "  check_for_updates()\n",
+      "/usr/local/lib/python3.10/dist-packages/timm/models/layers/__init__.py:48: FutureWarning: Importing from timm.models.layers is deprecated, please import via timm.layers\n",
+      "  warnings.warn(f\"Importing from {__name__} is deprecated, please import via timm.layers\", FutureWarning)\n"
+     ]
     },
     {
-      "cell_type": "markdown",
-      "id": "6a30b8b6-48ca-49c5-8621-260d507c8be5",
-      "metadata": {
-        "id": "6a30b8b6-48ca-49c5-8621-260d507c8be5"
-      },
-      "source": [
-        "## Training\n",
-        "\n",
-        "Training a YOLO11 object detector with AgML is incredibly simple. All you need to do is choose the dataset and model architecture that you want, and then call the `Detector.train()` method. The best augmentations and optimal training parameters are automatically selected by the YOLO11 package, and then a saved model is stored directly in the AgML model repository.\n",
-        "\n",
-        "**Note**: Make sure you define a data split! The YOLO model needs training, validation, and test data in order to successfully converge."
-      ]
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Creating new Ultralytics Settings v0.0.6 file ✅ \n",
+      "View Ultralytics Settings with 'yolo settings' or at '/root/.config/Ultralytics/settings.json'\n",
+      "Update Settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'. For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "\n",
+    "import agml\n",
+    "import agml.models\n",
+    "\n",
+    "%matplotlib inline\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a30b8b6-48ca-49c5-8621-260d507c8be5",
+   "metadata": {
+    "id": "6a30b8b6-48ca-49c5-8621-260d507c8be5"
+   },
+   "source": [
+    "## Training\n",
+    "\n",
+    "Training a YOLO11 object detector with AgML is incredibly simple. All you need to do is choose the dataset and model architecture that you want, and then call the `Detector.train()` method. The best augmentations and optimal training parameters are automatically selected by the YOLO11 package, and then a saved model is stored directly in the AgML model repository.\n",
+    "\n",
+    "**Note**: Make sure you define a data split! The YOLO model needs training, validation, and test data in order to successfully converge."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2a4bd294-4147-44e9-afa9-697e4225afa0",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
     },
+    "id": "2a4bd294-4147-44e9-afa9-697e4225afa0",
+    "outputId": "7d9dde8b-1c28-441f-bf5f-44780a948247"
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": 5,
-      "id": "2a4bd294-4147-44e9-afa9-697e4225afa0",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 1000
-        },
-        "id": "2a4bd294-4147-44e9-afa9-697e4225afa0",
-        "outputId": "7d9dde8b-1c28-441f-bf5f-44780a948247"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "Downloading fruit_detection_worldwide (size = 526.9 MB): 526893056it [00:07, 74443280.50it/s]                               \n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "[AgML Download]: Extracting files for fruit_detection_worldwide... Done!\n",
-            "\n",
-            "====================================================================================================\n",
-            "You have just downloaded \u001b[1mfruit_detection_worldwide\u001b[0m.\n",
-            "\n",
-            "This dataset has \u001b[1mno license\u001b[0m.\n",
-            "\n",
-            "When using this dataset, please cite the following:\n",
-            "\n",
-            "@Article{s16081222,\n",
-            "  AUTHOR = {Sa, Inkyu and Ge, Zongyuan and Dayoub, Feras and Upcroft, Ben and Perez, Tristan and McCool, Chris},\n",
-            "  TITLE = {DeepFruits: A Fruit Detection System Using Deep Neural Networks},\n",
-            "  JOURNAL = {Sensors},\n",
-            "  VOLUME = {16},\n",
-            "  YEAR = {2016},\n",
-            "  NUMBER = {8},\n",
-            "  ARTICLE-NUMBER = {1222},\n",
-            "  URL = {https://www.mdpi.com/1424-8220/16/8/1222},\n",
-            "  ISSN = {1424-8220},\n",
-            "  ABSTRACT = {This paper presents a novel approach to fruit detection using deep convolutional neural networks. The aim is to build an accurate, fast and reliable fruit detection system, which is a vital element of an autonomous agricultural robotic platform; it is a key element for fruit yield estimation and automated harvesting. Recent work in deep neural networks has led to the development of a state-of-the-art object detector termed Faster Region-based CNN (Faster R-CNN). We adapt this model, through transfer learning, for the task of fruit detection using imagery obtained from two modalities: colour (RGB) and Near-Infrared (NIR). Early and late fusion methods are explored for combining the multi-modal (RGB and NIR) information. This leads to a novel multi-modal Faster R-CNN model, which achieves state-of-the-art results compared to prior work with the F1 score, which takes into account both precision and recall performances improving from     0 . 807     to     0 . 838     for the detection of sweet pepper. In addition to improved accuracy, this approach is also much quicker to deploy for new fruits, as it requires bounding box annotation rather than pixel-level annotation (annotating bounding boxes is approximately an order of magnitude quicker to perform). The model is retrained to perform the detection of seven fruits, with the entire process taking four hours to annotate and train the new model per fruit.},\n",
-            "  DOI = {10.3390/s16081222}\n",
-            "}\n",
-            "\n",
-            "You can find additional information about this dataset at:\n",
-            "https://drive.google.com/drive/folders/1CmsZb1caggLRN7ANfika8WuPiywo4mBb\n",
-            "\n",
-            "This message will \u001b[1mnot\u001b[0m be automatically shown\n",
-            "again. To view this message again, in an AgMLDataLoader\n",
-            "run `loader.info.citation_summary()`. Otherwise, you\n",
-            "can use `agml.data.source(<name>).citation_summary().`\n",
-            "\n",
-            "You can find your dataset at /root/.agml/datasets/fruit_detection_worldwide.\n",
-            "====================================================================================================\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "WARNING:root:[AgML] \n",
-            "    Dataset successfully exported to YOLO format. \n",
-            "\n",
-            "    You can find the dataset at the following location: /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide\n",
-            "    The dataset metadata is stored at /usr/local/lib/python3.10/dist-packages/ultralytics/data/dataset.yaml\n",
-            "    \n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Downloading https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s.pt to 'yolo11s.pt'...\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "100%|██████████| 18.4M/18.4M [00:00<00:00, 147MB/s] \n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Ultralytics 8.3.23 🚀 Python-3.10.12 torch-2.5.0+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
-            "\u001b[34m\u001b[1mengine/trainer: \u001b[0mtask=detect, mode=train, model=yolo11s.pt, data=/usr/local/lib/python3.10/dist-packages/ultralytics/data/dataset.yaml, epochs=50, time=None, patience=100, batch=16, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=8, project=None, name=train, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=True, opset=None, workspace=4, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, copy_paste_mode=flip, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs/detect/train\n",
-            "Downloading https://ultralytics.com/assets/Arial.ttf to '/root/.config/Ultralytics/Arial.ttf'...\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "100%|██████████| 755k/755k [00:00<00:00, 21.5MB/s]\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Overriding model.yaml nc=80 with nc=7\n",
-            "\n",
-            "                   from  n    params  module                                       arguments                     \n",
-            "  0                  -1  1       928  ultralytics.nn.modules.conv.Conv             [3, 32, 3, 2]                 \n",
-            "  1                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]                \n",
-            "  2                  -1  1     26080  ultralytics.nn.modules.block.C3k2            [64, 128, 1, False, 0.25]     \n",
-            "  3                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              \n",
-            "  4                  -1  1    103360  ultralytics.nn.modules.block.C3k2            [128, 256, 1, False, 0.25]    \n",
-            "  5                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              \n",
-            "  6                  -1  1    346112  ultralytics.nn.modules.block.C3k2            [256, 256, 1, True]           \n",
-            "  7                  -1  1   1180672  ultralytics.nn.modules.conv.Conv             [256, 512, 3, 2]              \n",
-            "  8                  -1  1   1380352  ultralytics.nn.modules.block.C3k2            [512, 512, 1, True]           \n",
-            "  9                  -1  1    656896  ultralytics.nn.modules.block.SPPF            [512, 512, 5]                 \n",
-            " 10                  -1  1    990976  ultralytics.nn.modules.block.C2PSA           [512, 512, 1]                 \n",
-            " 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          \n",
-            " 12             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           \n",
-            " 13                  -1  1    443776  ultralytics.nn.modules.block.C3k2            [768, 256, 1, False]          \n",
-            " 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          \n",
-            " 15             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           \n",
-            " 16                  -1  1    127680  ultralytics.nn.modules.block.C3k2            [512, 128, 1, False]          \n",
-            " 17                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              \n",
-            " 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           \n",
-            " 19                  -1  1    345472  ultralytics.nn.modules.block.C3k2            [384, 256, 1, False]          \n",
-            " 20                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              \n",
-            " 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           \n",
-            " 22                  -1  1   1511424  ultralytics.nn.modules.block.C3k2            [768, 512, 1, True]           \n",
-            " 23        [16, 19, 22]  1    822117  ultralytics.nn.modules.head.Detect           [7, [128, 256, 512]]          \n",
-            "YOLO11s summary: 319 layers, 9,430,501 parameters, 9,430,485 gradients, 21.6 GFLOPs\n",
-            "\n",
-            "Transferred 493/499 items from pretrained weights\n",
-            "\u001b[34m\u001b[1mTensorBoard: \u001b[0mStart with 'tensorboard --logdir runs/detect/train', view at http://localhost:6006/\n",
-            "Freezing layer 'model.23.dfl.conv.weight'\n",
-            "\u001b[34m\u001b[1mAMP: \u001b[0mrunning Automatic Mixed Precision (AMP) checks...\n",
-            "Downloading https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt to 'yolo11n.pt'...\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "100%|██████████| 5.35M/5.35M [00:00<00:00, 50.5MB/s]\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\u001b[34m\u001b[1mAMP: \u001b[0mchecks passed ✅\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\u001b[34m\u001b[1mtrain: \u001b[0mScanning /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide/labels... 453 images, 0 backgrounds, 0 corrupt: 100%|██████████| 453/453 [00:00<00:00, 487.43it/s]\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\u001b[34m\u001b[1mtrain: \u001b[0mNew cache created: /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide/labels.cache\n",
-            "\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\u001b[34m\u001b[1mval: \u001b[0mScanning /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide/labels... 56 images, 0 backgrounds, 0 corrupt: 100%|██████████| 56/56 [00:00<00:00, 356.18it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\u001b[34m\u001b[1mval: \u001b[0mNew cache created: /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide/labels.cache\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Plotting labels to runs/detect/train/labels.jpg... \n",
-            "\u001b[34m\u001b[1moptimizer:\u001b[0m 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... \n",
-            "\u001b[34m\u001b[1moptimizer:\u001b[0m AdamW(lr=0.000909, momentum=0.9) with parameter groups 81 weight(decay=0.0), 88 weight(decay=0.0005), 87 bias(decay=0.0)\n",
-            "\u001b[34m\u001b[1mTensorBoard: \u001b[0mmodel graph visualization added ✅\n",
-            "Image sizes 640 train, 640 val\n",
-            "Using 2 dataloader workers\n",
-            "Logging results to \u001b[1mruns/detect/train\u001b[0m\n",
-            "Starting training for 50 epochs...\n",
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       1/50      4.49G      2.025      2.955      1.829         42        640: 100%|██████████| 29/29 [00:21<00:00,  1.36it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:02<00:00,  1.29s/it]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.381      0.291      0.264      0.143\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       2/50      4.41G      1.611      1.901      1.497         89        640: 100%|██████████| 29/29 [00:17<00:00,  1.64it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.41it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323        0.5      0.274      0.314      0.159\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       3/50      4.44G       1.53       1.62      1.394         95        640: 100%|██████████| 29/29 [00:15<00:00,  1.87it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.25it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.507      0.457      0.411      0.224\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       4/50      4.46G      1.499       1.55      1.383         37        640: 100%|██████████| 29/29 [00:16<00:00,  1.73it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.84it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.617      0.442      0.456      0.259\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       5/50      4.38G      1.479      1.473       1.35         35        640: 100%|██████████| 29/29 [00:16<00:00,  1.74it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.22it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.396      0.443      0.388      0.212\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       6/50      4.44G      1.432      1.409       1.36         58        640: 100%|██████████| 29/29 [00:16<00:00,  1.77it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.25it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.648      0.448      0.522       0.28\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       7/50      4.44G      1.417      1.358        1.3         57        640: 100%|██████████| 29/29 [00:16<00:00,  1.76it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.11it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.618      0.577      0.586      0.335\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       8/50      4.43G      1.408      1.337      1.316         62        640: 100%|██████████| 29/29 [00:16<00:00,  1.72it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.02it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.518      0.517      0.486      0.271\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "       9/50      4.41G       1.37      1.317      1.315         45        640: 100%|██████████| 29/29 [00:16<00:00,  1.72it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.04it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.468      0.611      0.576      0.343\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      10/50      4.44G      1.373      1.259      1.285         37        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.57it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.579      0.553      0.573      0.341\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      11/50      4.42G      1.376      1.242       1.27         39        640: 100%|██████████| 29/29 [00:15<00:00,  1.85it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.44it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323       0.65      0.447      0.506      0.303\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      12/50      4.44G      1.327      1.203      1.265         32        640: 100%|██████████| 29/29 [00:16<00:00,  1.72it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.74it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.573      0.656      0.604      0.333\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      13/50      4.39G      1.328      1.215      1.257         32        640: 100%|██████████| 29/29 [00:17<00:00,  1.64it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.07it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.636      0.677       0.67      0.396\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      14/50      4.46G      1.296       1.11      1.252         46        640: 100%|██████████| 29/29 [00:18<00:00,  1.60it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.67it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.581      0.581      0.583      0.348\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      15/50      4.46G      1.285      1.078      1.227         45        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.37it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.701      0.671      0.704      0.396\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      16/50      4.46G       1.27      1.104       1.22         35        640: 100%|██████████| 29/29 [00:16<00:00,  1.72it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.15it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.674      0.541      0.628      0.365\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      17/50      4.38G      1.314      1.122      1.234         60        640: 100%|██████████| 29/29 [00:16<00:00,  1.73it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.25it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.593      0.578      0.594       0.33\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      18/50      4.46G      1.246      1.053      1.218         71        640: 100%|██████████| 29/29 [00:16<00:00,  1.74it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.11it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323       0.68      0.681      0.739      0.461\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      19/50      4.46G      1.239      1.026      1.207         83        640: 100%|██████████| 29/29 [00:15<00:00,  1.92it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.56it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.657      0.664      0.712      0.431\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      20/50      4.42G      1.252     0.9774      1.189         54        640: 100%|██████████| 29/29 [00:15<00:00,  1.88it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.36it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.701      0.673      0.723      0.445\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      21/50      4.42G      1.214     0.9525      1.174         58        640: 100%|██████████| 29/29 [00:15<00:00,  1.90it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.36it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.735      0.657      0.726      0.433\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      22/50      4.41G        1.2     0.9505      1.178         60        640: 100%|██████████| 29/29 [00:16<00:00,  1.80it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.05it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.702      0.637      0.705      0.436\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      23/50      4.44G      1.189     0.9472      1.186         34        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.15it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.753      0.689      0.757      0.427\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      24/50      4.41G      1.184     0.9425      1.171         57        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.21it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323       0.81       0.67      0.758      0.467\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      25/50      4.35G      1.154     0.8815       1.16         71        640: 100%|██████████| 29/29 [00:17<00:00,  1.64it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.52it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.691       0.69      0.737      0.473\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      26/50      4.45G      1.172      0.892       1.17         39        640: 100%|██████████| 29/29 [00:17<00:00,  1.67it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.28it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.707      0.677      0.759      0.468\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      27/50      4.46G      1.154     0.8552      1.161         38        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.16it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.726      0.713      0.788      0.501\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      28/50      4.41G      1.141     0.8557      1.153         35        640: 100%|██████████| 29/29 [00:15<00:00,  1.82it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.71it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.723      0.765      0.799      0.497\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      29/50      4.37G      1.131     0.8527      1.141         64        640: 100%|██████████| 29/29 [00:15<00:00,  1.85it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.46it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.782      0.726      0.796      0.482\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      30/50      4.42G      1.121     0.8314      1.122         35        640: 100%|██████████| 29/29 [00:14<00:00,  1.98it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.33it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323       0.79      0.674      0.763      0.471\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      31/50      4.44G      1.127     0.7884      1.133         54        640: 100%|██████████| 29/29 [00:15<00:00,  1.85it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.09it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.743      0.676      0.738      0.448\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      32/50      4.46G      1.074     0.7499      1.101         36        640: 100%|██████████| 29/29 [00:17<00:00,  1.69it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.36it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.662      0.731      0.725      0.435\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      33/50      4.39G      1.081     0.7667      1.121         41        640: 100%|██████████| 29/29 [00:16<00:00,  1.75it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.09it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.781       0.76      0.806      0.476\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      34/50      4.46G      1.058     0.7319      1.115         44        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.44it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.732      0.704      0.767      0.471\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      35/50      4.41G      1.086     0.7611      1.108         51        640: 100%|██████████| 29/29 [00:16<00:00,  1.80it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.31it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.759      0.703      0.751      0.435\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      36/50       4.4G      1.048     0.7387      1.102         53        640: 100%|██████████| 29/29 [00:16<00:00,  1.81it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.26it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.778      0.662      0.757      0.458\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      37/50      4.39G      1.067     0.7336      1.105         51        640: 100%|██████████| 29/29 [00:16<00:00,  1.73it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.52it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.827      0.763      0.835        0.5\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      38/50      4.41G      1.049     0.7282      1.104         38        640: 100%|██████████| 29/29 [00:16<00:00,  1.76it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.80it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.771      0.809      0.846      0.509\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      39/50      4.46G      1.023     0.6731      1.074         62        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.41it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.782      0.785      0.822       0.49\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      40/50      4.41G      1.008     0.6794      1.091         41        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.57it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323       0.77      0.752      0.813      0.515\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Closing dataloader mosaic\n",
-            "\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))\n",
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      41/50      4.38G     0.9742     0.6427      1.074         28        640: 100%|██████████| 29/29 [00:20<00:00,  1.43it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.16it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.815      0.704      0.786      0.498\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      42/50      4.41G     0.9406     0.5991      1.056         29        640: 100%|██████████| 29/29 [00:16<00:00,  1.75it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.12it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323       0.75      0.723      0.775      0.495\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      43/50      4.43G     0.9236     0.5617      1.054         26        640: 100%|██████████| 29/29 [00:16<00:00,  1.74it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.03it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.771      0.768      0.799      0.507\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      44/50      4.42G     0.9307      0.546      1.046         41        640: 100%|██████████| 29/29 [00:16<00:00,  1.77it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.27it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.779       0.77      0.802      0.494\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      45/50      4.41G     0.9276     0.5584      1.063         20        640: 100%|██████████| 29/29 [00:16<00:00,  1.74it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.54it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.748      0.779       0.79      0.494\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      46/50      4.42G     0.8934     0.5168      1.029         25        640: 100%|██████████| 29/29 [00:15<00:00,  1.85it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.22it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.829       0.73      0.815      0.508\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      47/50      4.42G     0.8831     0.5218      1.025         25        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.34it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.784      0.774      0.825      0.511\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      48/50      4.44G     0.8758     0.5143      1.032         24        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.17it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.795       0.78      0.826      0.525\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      49/50      4.38G     0.8788     0.4938      1.034         21        640: 100%|██████████| 29/29 [00:15<00:00,  1.93it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.55it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.785      0.776      0.821       0.52\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "      50/50      4.41G     0.8503     0.5063      1.017         45        640: 100%|██████████| 29/29 [00:14<00:00,  1.95it/s]\n",
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.46it/s]"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.795      0.765      0.827       0.52\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "\n",
-            "50 epochs completed in 0.280 hours.\n",
-            "Optimizer stripped from runs/detect/train/weights/last.pt, 19.2MB\n",
-            "Optimizer stripped from runs/detect/train/weights/best.pt, 19.2MB\n",
-            "\n",
-            "Validating runs/detect/train/weights/best.pt...\n",
-            "Ultralytics 8.3.23 🚀 Python-3.10.12 torch-2.5.0+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
-            "YOLO11s summary (fused): 238 layers, 9,415,509 parameters, 0 gradients, 21.3 GFLOPs\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.07it/s]\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "                   all         56        323      0.797      0.779      0.826      0.525\n",
-            "               avocado          7         41       0.72       0.78      0.767      0.465\n",
-            "             rockmelon          6         13      0.907       0.75      0.896       0.51\n",
-            "                 apple          6         38      0.723      0.895      0.894      0.637\n",
-            "                orange          7         24      0.746      0.611      0.711      0.415\n",
-            "            strawberry          3         50      0.835      0.812      0.849      0.576\n",
-            "                 mango         14         91      0.859      0.934      0.956      0.678\n",
-            "              capsicum         13         66      0.787      0.671      0.708      0.393\n",
-            "Speed: 0.2ms preprocess, 5.8ms inference, 0.0ms loss, 1.8ms postprocess per image\n",
-            "Results saved to \u001b[1mruns/detect/train\u001b[0m\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "WARNING:root:[AgML] Model training complete. Model saved to: /root/.agml/models/detectors/fruit_test\n",
-            "\n",
-            "        For full Ultralytics training logs and outputs, see: runs/detect/train\n",
-            "\n",
-            "        To load the AgML model directly, you can run: \n",
-            "\n",
-            "        import agml.models\n",
-            "        model = agml.models.Detector('fruit_test')\n",
-            "\n",
-            "        and the model with the best weights from this training run will be loaded.\n",
-            "        \n"
-          ]
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "'fruit_test'"
-            ],
-            "application/vnd.google.colaboratory.intrinsic+json": {
-              "type": "string"
-            }
-          },
-          "metadata": {},
-          "execution_count": 5
-        }
-      ],
-      "source": [
-        "loader = agml.data.AgMLDataLoader('fruit_detection_worldwide')\n",
-        "loader.split(train=0.8, val=0.1, test=0.1)\n",
-        "agml.models.Detector.train(loader, 'yolo11s', epochs=50, run_name='fruit_test')"
-      ]
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Downloading fruit_detection_worldwide (size = 526.9 MB): 526893056it [00:07, 74443280.50it/s]                               \n"
+     ]
     },
     {
-      "cell_type": "markdown",
-      "source": [
-        "## Inference\n",
-        "\n",
-        "You can run inference simply with `agml.models.Detector.load()`, to load the name of your saved model. and then either `Detector.show_prediction()` for visualization, or `Detector.predict()` to get the bounding boxes, labels, and confidence values."
-      ],
-      "metadata": {
-        "id": "bAOlxF-ChXGe"
-      },
-      "id": "bAOlxF-ChXGe"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[AgML Download]: Extracting files for fruit_detection_worldwide... Done!\n",
+      "\n",
+      "====================================================================================================\n",
+      "You have just downloaded \u001b[1mfruit_detection_worldwide\u001b[0m.\n",
+      "\n",
+      "This dataset has \u001b[1mno license\u001b[0m.\n",
+      "\n",
+      "When using this dataset, please cite the following:\n",
+      "\n",
+      "@Article{s16081222,\n",
+      "  AUTHOR = {Sa, Inkyu and Ge, Zongyuan and Dayoub, Feras and Upcroft, Ben and Perez, Tristan and McCool, Chris},\n",
+      "  TITLE = {DeepFruits: A Fruit Detection System Using Deep Neural Networks},\n",
+      "  JOURNAL = {Sensors},\n",
+      "  VOLUME = {16},\n",
+      "  YEAR = {2016},\n",
+      "  NUMBER = {8},\n",
+      "  ARTICLE-NUMBER = {1222},\n",
+      "  URL = {https://www.mdpi.com/1424-8220/16/8/1222},\n",
+      "  ISSN = {1424-8220},\n",
+      "  ABSTRACT = {This paper presents a novel approach to fruit detection using deep convolutional neural networks. The aim is to build an accurate, fast and reliable fruit detection system, which is a vital element of an autonomous agricultural robotic platform; it is a key element for fruit yield estimation and automated harvesting. Recent work in deep neural networks has led to the development of a state-of-the-art object detector termed Faster Region-based CNN (Faster R-CNN). We adapt this model, through transfer learning, for the task of fruit detection using imagery obtained from two modalities: colour (RGB) and Near-Infrared (NIR). Early and late fusion methods are explored for combining the multi-modal (RGB and NIR) information. This leads to a novel multi-modal Faster R-CNN model, which achieves state-of-the-art results compared to prior work with the F1 score, which takes into account both precision and recall performances improving from     0 . 807     to     0 . 838     for the detection of sweet pepper. In addition to improved accuracy, this approach is also much quicker to deploy for new fruits, as it requires bounding box annotation rather than pixel-level annotation (annotating bounding boxes is approximately an order of magnitude quicker to perform). The model is retrained to perform the detection of seven fruits, with the entire process taking four hours to annotate and train the new model per fruit.},\n",
+      "  DOI = {10.3390/s16081222}\n",
+      "}\n",
+      "\n",
+      "You can find additional information about this dataset at:\n",
+      "https://drive.google.com/drive/folders/1CmsZb1caggLRN7ANfika8WuPiywo4mBb\n",
+      "\n",
+      "This message will \u001b[1mnot\u001b[0m be automatically shown\n",
+      "again. To view this message again, in an AgMLDataLoader\n",
+      "run `loader.info.citation_summary()`. Otherwise, you\n",
+      "can use `agml.data.source(<name>).citation_summary().`\n",
+      "\n",
+      "You can find your dataset at /root/.agml/datasets/fruit_detection_worldwide.\n",
+      "====================================================================================================\n"
+     ]
     },
     {
-      "cell_type": "code",
-      "source": [
-        "model = agml.models.Detector.load('fruit_test')"
-      ],
-      "metadata": {
-        "id": "AHAVxV6GTTaH"
-      },
-      "id": "AHAVxV6GTTaH",
-      "execution_count": 6,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "\n",
-        "Image.fromarray(model.show_prediction(loader[1][0]))"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 444
-        },
-        "id": "J3UwEF3kWtIL",
-        "outputId": "b4a8cf47-cdf5-4abc-e2a8-69279c05a53e"
-      },
-      "id": "J3UwEF3kWtIL",
-      "execution_count": 7,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "<PIL.Image.Image image mode=RGB size=640x427>"
-            ],
-            "image/png": "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\n",
-            "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAGrAoADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDw6WM56GoxG3pXaHTreSPIXmsyaxVGOFrFzsZqaMJLaRzhVJNSGzkU8rityzRUlwRWnLZGYDy4txPpUOo72HznIC0cjO04py22SAByTgD1Jr1rT/DMS6fG06xxeYON5xnHXA71n3cdhojqLO2j8zcxa5eJd/O0/KSMgDB/OodfWyIdW25zll4EuhPG2qvFawiXbLF5gMu0DLY2hgpHTnvUh03QbSS3aNbljG++R/N3cg5CELt4wMZGDzntU1zrLOWDPvLEncOfc1gyzGS4ZiflkbcwBxn8aI+0lrJ2FFzk9dDobLxPcxTw7b7UbQsxaQrO08XT7qxvngjPfgn0rsdPvbfX4DKNqzhdzqOoycZIH3TweDXmEaM8RyWLNyqrz9fx9h6VY+0z2JyrPDLn5dhA6HqSD0z+tYVKEZP3dGE4KSsehXGkI43AbHjOQR19vrUFxo0u1LiP7sp+Yf3TVbRvGsbBItQtGC7WaSeI5Ctk9E7LjHGeue3FdvFFHDP5M+1oZCCT1xnow/D9KVOpOlK0tjn5ZR0ZxbaNO6xsULfKKqy6ROIzGkeRkdTjAr15NJQRMQmccAHjgdOPpVCDQ2uppG8r5U4BAwW9a75QTXqVY8a1zSjaeXMOVYc8YwR1H9az7IA3UWVycnv0ODXtmt+D0utOltxIqhx+7L8bHHQ8D8DXiyQPZ6oLeVSrpIQyt1XGc1yVI8uhtF33NOzyB8okbPYrj9aZqERn064CF0OMgbc5ZfmAP+PamW8yqQAh57s26rZeT7LG0gjWPcSSxPTPpiuS7jNSI6ljQ9V0aa/sIbSKS1eSPbMSeC/Yg1c8b6PNF5d0qtJhfmYelWbf4R3xuk2ajbrHkEOFbcB7D/69eiWXhJRAItQvJb1QNuCAgIx3x/jXRKpBzUqbuEt7o8i8Ga9DZ6rDHckAbsAt2PavTr24W6WRpMbugwa37fw14e0+3Ro9F08GP7rG3Utn6kZzVS+tLG4t/I8ra2/crpxj1A9jWOIrxj7q6kzV0c3Z2lnBunlUMd3y57VVvY0vi5jG7jHy9qfrmzQ9Sjto9oiliEgMueD0Iz3/APr1kXPiqGwQs6xt6BO9YN1rW5dBKjdXuZEvhNtks7g7mJ2gjGKwYvB17fO0iyQQW4JBkkfPPptHNaWpeNr3UYJIFRIImP8ADy2PTNVLLUGi0qVGJCeZwc9TXVz1lG6Vn94/eiczcWM1jdy28y4eNtpwOvuKltrSN5AzDBHb1rrF0/T9X09b+e8+yyL8kh2Ag46fU4qp/YcsFzHfWKPeWIbIYgbj65FdUcTFqzdmXzkFpq4tNViaaL/R1+VlA7etddd+EP7RgF/otzG0Ug3eW7cD6GuF1Qot+5jVljb5trDGPUVt+HtTvtJjaRVeWxb72052GiDSia05paPYVre90DUlWVkLsv8AyzOaZqeoXeobYlySRjao5qe38RWS6lJMYCwc9TziukstW0+6JZBHGQOWIrhrYidOV+S6Ib97Y4iDwtqcwL+WsSDq0hxVOWxeCZkLo2P4l6V3WrXdpeW7QrqR3dhHzmuVZBZxt9o4BPBPetMNWqVXeSt8gV5PQm0KU21zyuT7c12r61bXFpH84Uhtm4nGPb868ru9Z8ri3JXB5IPWqD6hdXbBPMkcyHG0t3rtl7SVJ0n8LFGi+dTue02CrbXskC8bk3Ahc9/ar9xfeVENhwx5JcFf/wBQrB8OteLY239qwiO4EeCXON+OAfyxUusNi32wJHuBGDvYY/Pr1r5irRftuSW51zTlqhbXVZmvgkt1HNDLlVRYy2XONoDY5HsKfr9qureGLyNUPnqPNj+UnBTnH4gEVxSWk9zrFpBEZpnmkVEkZSg3e3oPevT44vIZI0PmCNQxOCcn1/rXY6Xs+WUdzhm7anhuwsM5FMMTDtXW6to/9nanLhBs8wnbjpk5qLyrcxktEhr1ky+YxdJBFzIBxmJuR2wQauRqBcqWTcgcZz/tcce/GfwqsJ0ivN8a4UHBUdx3roptHnOjDV7KUTQKuZVj++nrkfTGf8KyqOz16g9zkpG3yl/LLZOctn+lLwATySPw/AUqQPIzFUYhOWY87f8APp3pyIJXCKjMM4G0ncSfbnmtTVOwxSpA3bk6gBhkD/J9qu2ZjYnYQMHcSeBxWlaeENUu2McdhclypYAlCRjqMeuMVgana3Gj3z2d0ksVyv8ArI5FKsgPIyD3NHLzLQUZ3Oqin/0UENwBxWLO5YtnuaSC8P2VQG7VGz7utZqNmbtkIJJpwU4pQADUgGegobIGqoAzTgw4IFO27ePWo2OMqKnc1itR00vBA61d8PMg1JGfvWZ5Z3Fialtn8mZXBwRzQ9tD0KFRQaZ0PjBFeCKUDkcZrh3Bzk11etX32rTlXdzXKEE1dN3R1VqnNK4ucEY6VfsiN4Oec1RRBu5q7a5Eo44FdEHqZ82hPc83BOaIbqa2cPFIyMOhU1DMSZWJpvXvWcn710fP1LOTPTvBXjGW7nFhetl8fKx716LnivnjSrg2epW84P3HBr6AsZhcWUUg5DKK97A13Vp+9ujzqsFCWmxYooo712GYmKKWjFABRRRQAUUUUAFJS0UAFFFFABRQaSgBcUlLRQB4LDMiqQ2FOT8vXjt+NNl8mdSEZC2M4VgT+XWs0TbgzFRnqQOuO2ap3CgHeMg5zx2/wr5ls9FFyRPKcg8EetXLDWhaON4zWBDc7CIZifLzhTjlD/h7VJINkhVuMcHNS433NI3Tud/Bqx1nWobpcmNYWi5OAvH3QB07/nTNTtBcqdpwQerCuR0zUp9JuVuI0LREjehyFcfXsevNehGKG80+LUbQl7Z8ghl+ZD3BHqMjmseVxdzGqnzcx5jewvb3bqVYMvDhhjnuKjVwD+8Tep4bPX8D2Ndjq1itxBJNlQxwrDP3sdMn/PauPlhaFsMCAOee4rpjJNG0JXRPu+yl3WUnahaJxwSCMA/qapKQG9F9hUzPm1KAklTkH2zkj88H86gRS7AAZJOPrStYZ0ekWhkRZG/1bKWLjnI9B6HPGPWuoXx3J8yf2fC8EcGxVWbO2Qcbs44HbH0rDldLHQ1iDffbop4OByfqTjn0rAkt5I3N1BIwLjEqLxkev+IrlUVNtsKkI6JnUL478QrcCU6jIrqCAAowAe2MdOK7rw98T4bm2MWrvHbygjbJGnyvng8dj39K8cgTzEK9Wz8uD19qkjPzAEkYNdbV43iYONmfR91qMMwbyXMiAbvlO4EexryrxzbWiatFq2nuHEykSY/hkxwfxX+VQ+HdeurWJLHI2ZYIx6qTzgfjUmryNcpJbqMbh5hBHU56j6H+Zrz6lVudrBFtSRyEVyzORgNIxwoJzk1tzRQpbw2yuzyKoUKh3BmJ9OvU1Bo9oxmLW1u09wT95sBIV6ZJPetfSkY6wrzzxPJGd0Pl9GPI+p71nVkr6dDWa5dz1KznLSKwypDEcdK34HSRNxY8nBANcXY3zfZV24+Vzk+/FdFpsjtbNHj5t+5j6A0sJJLRnPF6lu8dpWCryo4X3Pr+FZNxAS0aLkkjd1rTOVfcSAAKiA8xiw5J5HbFbSoqTu1qxvU4zx9ZrdeGsBW8+3fzEwpY4xhh+I/lXmGoeHtTstFg1W8jSK3uCBAryfO4IJ3BeuOO/qK9/W3jmcrNGnlqMuDyTXn3xF0ptXuxcWTM88MQLQH+Meq88EAdO496pzVN2bNIxbWh5SF5470qsxZVDcZwoz3qeKAvGZFGR0FdH4O1210K4n+0adHceaP9aPvqPQZ4Izz61tNuMeZK4rmtpugWg0CCG/DRzSkkrLlGH0HX+Va9hBp+lW6xLdylAPuBBz9Sc1o3um6XrcazZnilPzB45PmGeeQc/lmq0fhW1RBv1G8kI6MyIMfpyPY14VbExk2pSt5W/wCACpSeqKOp6RoOuxCSaeaAoCFZGXIP4jn6VlXljp1lZPp+jzzuzDc6TEM7+4wMevArcl8JxsSw1aTZ1VBAMD6/N/Kli0eytbhZUmmklU8OyLx74+nFFLEKCsp3Xb+kU6c9mjy640a7eSX7HGTIvLoeCKj8PB7jWI7abICt+8VjjpXo9zplxDqQvbRFkMg8uZlz8x7Haefqfen21to66vAt7ZRTSW+Tubu5OSeOv4161PFx5FJi9o4O0kRapphgSKTSdLecHhlhTofXP/164TxDpHie4nZp9KuVWPsgDcfga9m1bXZXXEYATsqjArzDxFqVyswQSlH6naxFX9Y5pL2evqHt23ZI86ZHDFZAQQcEHgitCGG3kiAztcdCK6m+8LXF5ZWeqRqxiuUwzEdGFY0nhzUUufKjiLE8gjoa7IT9o+Vbm3OrXZt6L4mu4DDZXbmWBThZCeUBrotQK7Y2Xe5DjJA/Uf4V59c2OoaYM3NtIq/3sZH511/hvVo77TfLuHO+IhG56/3TXBjsM6bVS1u5tRlFqyG3FtczzJeJAbN0IaKXzgXduxxnA+teieGIZNQ06S5vLlzIiILjbgksSeMjPbBz71wb2TC+k/0OU3Ef97JVc9Dzxz7Zrf8ACd7Jpmi6lbyQus8l0GbaMAjYMcDAHfJ/wrmjJJXfQ5qkbKz6FDx/N9k1NQyqBKgKgDGMcEH9K5hYftMWFJDMO3arfj2/S51S1CzeYFgIOF2gNuOce3H6VX8N3AZtjj5hwK7qWsFIzW1yvBoE4uV8w/LnmvQLZH0rQ/MtW8uQzINwODwCce456VWdEZU6D3rVmiT/AIRUzO8YwzsgLfM7ZVcKO/Q1tUlH2Ml3HSTdVHA+LLZI5rZ7VFisZlMnkoNqxy5+bjpzxj06DgVixztZusuzJAOwMea3tYvmtzDFFCklyEPzuA3lAnkhTwTx1PT071hW9u88wSPLSOwHByWJ7YrmpN8lmdk4xTfY29G8W3GnXCFw7WigtLtI3MTnue56VQ8aaq2vCz1AQOsYMkYdjuOcg7Se+K7bSPAdlGEl1Q+fIDuEKnCD/e/vfyrc1jw9Y6horaclvHDEAfLWNQoQ9cgD3og4KSaOZzS+HY8LtpSMLnitJDuFZ15aTaXqEtpOMSRtg+/oau2z70BreoupondFhV4FTxrg4NMXJFTKO+K52ykDqCKryptGRV0plcgdKR0Dp0qUzWBnkfKG700qS3FWxGFGGXrTjAAoI4zVXNlIpTo7IATxVTyjnFaMxKrtPWo/JLKCB3qos3g31KgTIyRXReFfD761eFCSsajJIrMhspJ5liRSWY8AV7D4R0VNJ09QQPNblj716OAo+1nd7IwxuJ9jSst2cHr3g+601tyRtNEf4lHI+ork57ZoW5Vl+oxX0a0aSLhgDWDq3h+0v42jkhUhuvFejPLKU3eDt+R4SxLXxK54YmQwz0z1r6B8PsraLbFTkbB/KuBuvhswVmsrllP9yQbga6nwil/YWgsb6HaY+FYHIIp4PC1KDkpLR9UTWqRnZo6jFLS0V2mIlFLRQAlFGKKACilxSUAFFLRQAlFLRQAmKTFOooATFLiiigZ8vu53g5I4HemuSjEZ4PT6U2WN422SKyMOxphPTB6jk180ekMlQnp+FOjup0RVWZlUDAHtSMxbhvTNRkkkcUrDJjM5k37wGxjjjP4VueG/E8+h3JWUPPZSnMkQbkEjG5ff279K54E447Uvv2/lScU1ZlJJqzPW7qzjms0urJ91tPCsijbghG6EVzF1YABkkORyOvOOmRn8Kp+GvGFzpASyui0+nFgApPzQ5PJX2/2fyrubvTILyBbywkSRHT5Spyki56j0PHT8Kwu4O0jBpwZ5hdWckBXcCVGRke1O0u1Ju8gZKY2njBz0PI98/hXUajaF2aOaBk42/MNpDD+XasD95Zny3TDKcOR3z93+Z/StXJyjZG8Hd6ljVphI/lBmIQDZ74HP5jH5Uy3VpLZWGBgYzVKZ1d3YEEZ6gYzWjp/zWTgEH5yHBPTI4P5g/wCTRycsLIKruZlzGLUmdcqo64HT3/OrWYr6BJoHUTAcgHrVuW3VkJIypHzA9weDXJgvpt9InzYVip56jsaum7kRXMjo7W6kilA5VkPQ9q7OW0eWwivRMZYid2ckNgjpn61wltdJeIOQXHAOcEfWum0bUZ47WS0lO+LyztA7H3rlxVP7SC2pUjL21/fxr5m6S1LxqgySc9Mfn+VaemWUd1ZRN5/lyWsgIU5w4PQDHTnNZk909rrVlcEKTESmD75P88/nW/oaA3ziJmEUy7lZBxtJyP6iuepdQ5grapM6vw5BO9uqlGdEYcryTxjrXcabALWAsSd8vJz2A6f41jadHDbSm2tmyZ8IMgZBPc10ElrEUUq0i7cAMrkdP6VWHit+plFWVxHHJ+X5ahGC33Dg9x3qcRMc/Nn2PepVh2neF+orquOxl6jOlpFjI+Y4I7+1eZ2+qLca7LMsrZHzZPBBB/p2qfxF4qa4uZRFJuVXwpHQjvyK5rTsnUFlJIRmy5I7E1wVvfiz1MJh2zuItH0e4/0qTS7ZndtxwrKGOck7QQP0q59m0+XWHvZtPiVpIRC7Dvjocf164py7YkLuBHFGvXdgADuTXN3Hj/RLa6MSpcTxj/lrGo2n6Z5I968yhPEzl+7bf6EVo0l0O2ZFAMcflrGeNqgYP496pXUEluATloycBv6Vylx8VNHiTbDbXkz7eAVVQPxzVP8A4WrZtC0Vzpdysb8EpKrY969CrhJVYax1OKDlF6bHVq+DtUfjmnny1AMn5Vk6ZqUOo2S3MLHa4+UnqadNMy53c147pNS5WdT3NgGEfOvGB2OK5y9uLa9vGQ2TW04fMc0ced3qWPfNTJdSbyuCARznsKkV0Lg9SO9a0b0W3uZtKSszOnupLe5ZLgiNowOCemelcZcWbapq4jjfLSvwT2H+Fd/qumJqVk4EkUUyjdGdmc46gkc/4VleGdIihjF5cZaWVRtQjGwHtXpYatHlc1ucUoezZ09hGsWnR2IIaOJAp9KvWGhwz75AVBXoKzJZQirDEoXPpzV21umsCZdrSAIQQBjNa4as6VVTRmpX0exV1u2s2tnilVeBgg15JFNb6Z4gPlEG2kOxxnjBPX8DXTa54nGp3zLErJGeCT3rldW03yV89Oh6ivar4hVoqDRvQTjLmPRxqcRsmPkiQID+7zkj6ZrOubTUPtMS6db7prtlijQcAMQTuI9MA89BWP4d1IzWsSSsWAHlupI5IHB/KvQ9Fkih17TbiIkee4hIBPRxjp78V86oexrKDW7PSlFTR5H4t046V4mls2uDOUjiLOVxklQTgdhnOKr2uofYZ1bGQetdN8W7P7P40WRUKia0jf8AEEg/yrgHSaSQBFZ27Koyfyr3IpM5Wlc7GfxWiWhCElv5V6Dbx2a+ELdr65RZ4LCH5N/PmSfvGJH0bHpwc153oHw913VnilurJ7azLAyNMdpKd8Dr0zXojeEZvEcs2qmdLe3uWJjTZligO1fwwOBWdSPNaERpxjFyODSyttZ8V21ok7TLdS/vHjXaEQDJIJHZR6H61s6wNJ8OeMYLW1txbRRQooBYsdxGWYk9/mAz7V2uheCrHQr19SLSTz7DEjP0XcfmOO3yg8+9T6b4a03V7ePWNQs45Lq7ZptzrnCFjtH/AHzipVNt8q7Gc5uUL9zNtNTjuceU270xzWg880UZZ4JQoGclDW1JNp+lLsghiVgOy4ArlNZ8bys5htnYbhjIGf0pexjDd6nO/U4Hx5bJe3cd1bxlpvulVXJaszSvDusXEeU025AB5LRlR+teqaTa3twyX2oyPFGJRshKjLjGTu7jt+dbpvY7OHznVlijGMRqWOewAHesKmKUfca2NYSa0PPbX4b61IoM0tpBkZKs7Mw/AD+tXB8M9UTcTeWeB93Ac7v04re1TxklmVW1tWcvgl5vlXHcAA5z2z0zVuDxLMY1kdYlRx8gQE8dsk9/auaeJUVdq/odEKVWSvscdceA9at4C6pBPgfdhkJY+wBAyfasC+0u/sSRc2lxDt6l4iAPx6frXa6xq187M8N1LG+3acSFOD6AcVmWerTN5Ynurl5VXCs7+ZDEuOhU5z3J/DrzTp1XNXsaWnHVnKpbS3EscccbSO52oiDJYnsBW/b+CdQmKma4tYkB+Yq5kI/IY65HXtWpZ6qrmW3jtoYZ3yDcWyBHcdldcLxz2H1zXUxm2s7YWbBnuIl+eID5Ub0Zux9hmr5nexEqzWxwk3hCzJIbVG3dVK2vGO27Lcfhniqr+FrrysQSWtyQPuwSEsfopAJ/Cuyv44XG5osBDhVhVvmb3PP59q5x2YSHgxrndyDgfial1JLYSxNRGfaxnRbtDPEyOpAYSLtIz9a9H069SWBXB4IrmbPULlUXZduIl+6N+R+A6YrRtLyFRzbxKhOSYgUJ9xzj9K6MLm/1f3ZLQ5q6dZ3b1OmW5U96PNVj1rP+w3TY8uC6RiPuyQsR/wB9Af0pv2PU45MG1mI9VQkfyr2KGf4Wq7KS+85pYeaWxsRspFSBR1wKqW8N3xut5h9UNX1hlI5icf8AATXpfXcM1dVI/ejP2c+zGUVJ5Ev/ADyf/vk0eTL/AM83/wC+TR9cw3/PyP3oPZz7MjoqTyZf+eT/APfJo8iX/nk//fJo+uYb/n5H70Hs59iOipPIl/55P/3yaPIl/wCeT/8AfJo+uYb/AJ+R+9B7OfZkdFSeRL/zyf8A75NHky/88n/75NH1zDf8/I/eg9nPsR0VJ5Mv/PJ/++TR5Ev/ADzf/vk0fXMN/wA/I/eg9nPsR0YqTyZf+eT/APfJo8mX/nk//fJo+uYb/n5H70P2c+zI6Kk8mX/nk/8A3yaPJl/55P8A98ml9dw3/PyP3oPZz7EdFSeTL/zyf/vk0eTL/wA8n/75NH13Df8APyP3oPZz7HzVNEJE2Ohc54PcfT0rPubSS3VS2CucZU5x9fSujkgQOVGAAOMc5zVaWJdwYAY+6w9PrXjuB2KRz2AB+YzimMCSR0B7Vq3GmZXNsHbnlcc/h61SaFhyEYnttGagtMqgYx605RnIqZ7fa5HJP8qPKA5P6UWKTI1Uk8V1Xg/Xv7Iuns5UkkgvGROHx5R3cMB0Oc4Nc8sWcYyMnke9W4YMEFcg9valKCkrMTZ7Deww6jEvmr58RJ2seqMOuD1HGOK5HXvC8rwNNbbp9qAbVX58emO5BHbrzVPRfFNxpVssMitcQRyfcc9VIxwT3HrXZ6bfW2q2S3NpJ1+9GxG5DnGGGeK4Vz0nZmMrxd0eQYZHeNhtdThgeorR0ORE1AwyDMcqlcH16j+or1mfRdNv4Q+o2sN0zD5QQcr/AMCGD+Ga5m78D28V3Hc6ZM0RRw/lSnepHs3Ufjmuj28WrS0H7VNWZgXkXkTCTJED/dx2Poa5rXrPJS8QcEBJMdj2P9K9AurSS1BF1a4jbAbj5Tj0bt3rCu7RF3W7AvBIOSe47fiKIT6lQkkzgVDI4ZCQR3HFdh4Vvb66uv8ARlDXNupkOAPmUdcg9a528sns7loXGe6t6j1p+nzPaXccqZ3DqAcZB6j8q1n70TqcLq6O11/7Hd2cl9FF9lvIgryQEYV8EfMn+FWPD/iVNGSWw1CFzbSSCSIlcMFbnK5+8vQ103izxl4e1bwvDp1paLPcC2AV3Tb5A29Af6VyOjeMoYILLTtUgS4tBEAhkXeFxnjB6fUflXLKmpwcbXRDg3Bp9D2DQpItRu7Oa3mjmhQlg3XJCnkehzVu58SadbTzW/2omS3TfKFQtsX1OBxXNeFr7S5b6caIoiC2ss0oT7u4jAx79elcX4t1CTS9FltIIVh1HV3E92sZJZVIAC+vTA+pNc9OEl7ie5Kp2Wp6HJ8SPC0Fq0q6ykpUZEUaMXY+gGBVTRviLL4huBDbae1vE7N+9kYECIDk/wC9j8Oa80j+Ht3pOi2+s6/JHarMwENgxPnOOxYdh7da2/DxFqmp6g02FS3EKIF4jDHJx+Q61rNezdrkxjd2RkXys2oS5K4DHouBj1x9KV2a3eC3jUFmIZgffoPyqGCUMjPKAFXLHAxx6Va0VkczX9wQZZCQo67R7VzTel30PeqTWGo3W7Om/t531GGL7sTfKA3qRxVmfw3oNy5kn0e3VyMExkxg/gpA/SuK1G+X7Wjx7AyHjBzk9s1SuPiDqy3DxpFaYUkbihJP61zLBVpWdB8vfWx4rvJ3Z2F74E8PXSHyLWa0ftJDMzY/4CxINeb+JdBufDt8sMv72CTmGcDAcdwR2PtWtJ8Q9ciAI+y/Tyv/AK9blnqH/CX6SkGpRpEJGA3jOwHPDeorqoLGYZ3rPmj63YbLUwfCes/YgY2J2LyVH909fyPNdvLcQXEaOreYG5Ujp9a8+1rQpPC+qBluElhWTy3KNkYPBwe4rd8PySOksO8Hys7VY9e2aMXRhJ+2gbRalG/Y1J7xl3RxRcg5Zi+Sfc1Xi1EliVcPjjKpxVK/lCMcRgge/wDnNQwu3k7pGZEPRUXtUxpR5bitobQ1N4yu0EMTwSN34Yro7S2nmwsKbywzuGMAfUcVwIfe5wzFQeCTXpmkSiDRbONZUO2PkKMdeRVKjBbnNiIXRZj0kxRhgwaUn5jjp9KZqFhOLKRSCCVI461saQHn/esP3QOAfU1e1fVLXS7E3d1FI0CnDFIi+z3bHQe9dMsLGcLxdjmUL7Hzle20sAcxkNtY9OoqFr7z7Exv94DFdx491rTr65sjpMcUu/d5nkJ1zjAPGc03SfhsXsrq91ZnifYTDbxnlTjPzf4V00ZXVpmt7LU4XQpGW4eI5w4yMdiOR+ma9I0eY3ut6QinbGtzAwxkEHeOB69K4yBI7VvkRflPP4V6N8OIIIPEeqWl1bxtc2scdzZzMCT5TDqvbo68+5rHE0uacZndhqnNBrt+TOi8ReE9L8R38c+oxNJJBGUGGwME57dauaX4Z0rSolSzsYIv9oIMn8avXa/6ah+6CeVB61M8yQJlsepzXVSimrnJWS5zP1km10i5aLAkK7Fxxy3Aq5Z2gtbOG2z8kMax/kMVjanfpLHaru4e4Dn/AHV5qKTXcyrCpLPI2AB6mhSiptilZQS76l7Wj9qgfTraQLNLEcvg4jQ/KzHHfGQB3zVTUtbhsbb7PAVjjiQKq56ADAFZp1C9v3aDTYvOllOSV4VFHClj9Ofxq1H4UhtgZ9RYXd2ecH7ifQd6IczV11JnJvRdDAVdU1iJ5nZba1cnMsvdf9kd6bDd2OiCT+z4/wB8w+aeX5mb/D8Kuazc3LzrGASi/dAGAKx7GGW61NbeJUZi4dt3RQvJOfasKtRQ/wAzNauyOrme4AUTxZaGFQ/BwXPJz+J/Ssq91IOgjkjBcDAKjaPc9ufaugvfKeZpAmckkZ+brWNPZRFyUK8dlI4r5yrXjUqN9D1aNDkWu5z0tv8Aahhl3Rgg7lB/WiC2mgcBWJTrj/6x71sNEsZwrOP+BcfjVSSAmTKb/MPIQNn8Bjr9KtVbq3Q6raDXie5ULkM/ZfX86oX+gzwI1zbsCcMTHH154yM8Vu2dqilneUCU8YVuV9vr71b8mRDwzFe+eoqFiHTl7pi2tjm/D062+rwzXVlKAqMDI5Lbj2Pbken/ANau6WeOGFREEWED5RHwuP6/WseaxF0m0IoyM5H8PvVmKM2tskSKuF7gdSTyazxFZVdb2fYxtYvm+lIyGIB7s1RteO68yMwHGd55/DtWbM7uNqgksecjpUahhtToM4yT265P865lTW4lJlye3gvFxNEnB6hF4/HFLaaVAdVtJ4HaMLMpKclT8w6EnI/l9KiM0e35io9s9R6VPY3O/UrUBJMGZQDsOPvUVJ1OR69GOyb1Ra1zW9Ss9WuIbaYrGm3AEan+EHuKxx4x1eK4USOXjP3hsQH6jitTXUR9auFkDAfKAwJ4+UdueK5jU7U28TOYhIpPDoCy/T2+hpYHD4eVOF4Juy6LsZVnUjJtN2O5tdUupo1kFyHRhkMFXkflVxby4PWT9BXKeF5XGjoHXAEjhTtxkdf610aMCK/RcNleXVaMZvDwu1/JH/I82deqpNcz+9lr7ZP/AM9P0FJ9sn/56foKhoxW39j5d/0Dw/8AAI/5C+sVf5n97Jvtk/8Az0/QUfbJ/wDnp+gqHFGKP7Hy7/oHh/4BH/IPrFX+Z/eyb7ZP/f8A0FH2yf8A56foKhoo/sfLv+geH/gEf8g+sVf5n97Jvtk//PT9BR9sn/v/AKCoaMUf2Pl3/QPD/wAAj/kH1ir/ADP72TfbJ/7/AOgo+2T/APPT9BUOKKP7Hy7/AKB4f+AR/wAg+sVf5n97Jvtk/wDz0/QUfbJ/+en/AI6KhoxR/Y+Xf9A8P/AI/wCQfWKv8z+9k/2uf+/+go+1z/3/ANBUNFH9jZd/0Dw/8Bj/AJB9Yq/zP72Tfa5/7/6CnxXUzSoC/BYA8Cq1Ph/18f8AvD+dc+LyjL44ebVCF7P7Me3oVCvVcl7z+8+fJDNCSrjB6MDUSyOjtJ5W4HqQf84NS6V4tjuFEHiC3NxEFwt3En7wHtuH8Q9xz9a1C/hy4w1rq0Y38bJN0Zz77h+tcfO1ubOEkY8c6hlPlS7e4K/kc1PujuMjypDn7zKvQfWoL+/sbWRkgYXDY4YfdB+vf8KxLnU5pG3eawIPAU4A+goUpsqMWzXl05pCAhQeoL5P1OOtQnSZA+WniHoCx/wrPg1O7fksr4/vjP61bGsGPiRHH0bcPyNQ3VRpyonXTpVJBkjwR2bn9cVajsplGVid16ZQbv5VVi1W3dhtkC/X5f8A61acOrPBtZESRSOSKzdWrHoDgZZcsCrHg8EHgCqNrqd3ptz51tO8UynBZT1we/qOK6O5k0zVC83FveHk7hlHI/vD+v51zzQRDUJGucBAcsF9e+Pxq41FUV2rMSVj0Pw746W9kS3v7YRljzJD9zk9dvUduma7lLVLuJpYZFlQH7yHOPrXi1vqGkRMRDmJl6Eg8+9XZfFU1iFktJXWQc7kJFZOnd2S0M3BN6o9dSyVUO5t2RyF4/nVO58PadcsjSWcUm3JAOVxnjoCK85svH/iJ4y/nwsoJI8y1Xj2yOtWH+JHiIW4jZLI5HDG3PHuBux+lL2dun3DVFvY6678G6FOENzp0ZUcg73GPbOaqy/D7w3uQNYmA9d4unX+bVy5+Imp3JMcgitkPG+EEkfixJoufEN5CovJJpLosRlw3IUf09qzm6kdI/mbRw9W17/idFN4J0Pau24uYwM8CQEYPuw6d68mndLaW3LYdVLpuXocHIx7c10114z1C8EtudscO37m0EuP4gT9M9K5fV4GS1KYwI5/0K8fpirwsa0W/bPfZG9KPuyueh/CfVov7Y1NEUjGnSOgPPK81H4M8YQQRX2varZLqOtl1FpuQYjBHO33yfTtU3wf8L+bZalr8uoR29v5cllhxnBKcsSSAANy/Xnp33ofhn4dTTYYbTxPHHqKPxdRyLhiOceXv9PfNc1bMsJSqypuTutNFJ276pFckpJWRw/ifWda1bU/tmrCVWb7iOpVUB6ACt3QNA1G80+5iuoDbwzbGjlkO0gjr8vUjB74rttM8E6bp873Wo65HfX7c+ZLhEX+7tTccfXPPtW1/ZcKqhOsQDurgAH8PmrJZngno2//AAGf/wAiehhMJTj79V69rM5CHwfpVtasZUlumzhjMSE/IYqxZ2VtbKFhs4UjH8KoAK6saTa48w6lG0rZ3OxBB/Dd+nNOi0S1Qc3wZuxGB/Wt4ZpgEt3/AOAT/wDkT1o16EVt+DOVezhnX57WA+u6If4VjXXhLSbht32NYnyTmL5eT7dK9F/sKDqLtR/wEcfrUUmhW5zuv0B9SB/jVf2pgO7/APAJ/wDyISr4aouWauvQ8M1j4f6mLljp7R3UeCQpOxh7YPFaVhYXWm6XFC8bJMq8owwQa9Vl8P2Z5bWIF+oH/wAVUL6Dp0ilZddtWx93IXI/8erGtmmElHl5n/4BP/5E87FZdhqkb0ZNP0bX5HjGumS9thFKhQhgefrUl1cjT/E84tW2QGTaAf7p7V6bq/g/QprGT7T4jsbeJhjzH2ADPuXrnrj4daKs6Nc+PNOSXYrfOiAsMDBwZehFYLNMJy8rbt/hl/keRChVheM0YJVby68tWUjksAM8DvUNxKfN2q+6M9Apzn/Cu6g8H6FHalB4vsGLcmQFOnoP3nSqzeBtBWZm/wCEy01QedpCcf8AkSsoZphb6t/+Ay/yGoS2OLiGASYmXb0A5zXpPhaQappMf2hHCwnYu7+Ij+lZGp+DoLPRJdV03WbbUYYXVZBEgIySBwVY85ZePQ/n0GmmG3s4YoEwQgJUDknuTXbh8VRxC5qbuk7dV+ZhifdVmdNEwEYVXGAOgOKhl1CG0UtNIdvTisK51BoxgkrgY/GsPUNUBQIZdh5wwGcHtXZLEpKy3OLn7Gbrnhyz1Z7jU9NkS2V3KxwmPajkfeJP8PJ7CuJlfUrCeSFbi7t5RgNH5zDIHTHPIrbutanubhFtzL5cf8LcZHfNXDbx6rYKlyuHHIf+4T0//VUKo7+8jWnWcXaWxySXc28iX5+edwwfzrt9E8TwDxHoF55LW8kMA0+5Odwkj6Bu3QMePYVyjWYVpInZS0ZwcHlff6VEsLRONw49cdauTaPRo8qkn0Z9A6xFe2gM9oGlMbEtbAhfOXp94jAI5OOM9K53UdbZyYVRiXO1RnoTVnwT4rTVbe4sdUl2zW6CRJCCWkj469clTx9MelTt4cs73VWuor55LcNkKgwQT79vyrVNte4cuJpyWnYxb15HNlDHE0s3lkiNRzkn/ACnXOkS6VElxfSBLqZHKRqwHlRKuZHJPGduQPciuh06W206W9u3ZI4onWGPfyQqr0Hqea5GZNT+IWoXqcW+hybYJ7k43kKwby4jg7jwN38OT3wKmEVJd2/yK9kubmlskj0DQr2xvNBtL3TrX7PbXMe+NWXBK9AfxA71NIFIPA59ar6TYQaXpcVhbNM8cIO0yvvY5OTk/wBAABVzapXhCCPau++hzyavoc/qmnJIhxHn1xWNZWsWlzNIcLLJ8gOe3U/0rrrsPLFgDHrXDam4+3CMvxGrMQf71eXmMF7N+ZeGinWX9dC3qWpmFdkLfvG6nPIFVtOjT7GTJgeY2SS+N3+cVkStu2n69K2bRXexiCgg7cHaOa+flTUIWR7L0jZDnXHcnHUZpbWJXzISy84UdMe/NRmSGI/vLiNQONpOT+lVZvENtGdm+Zz6JHtH5saI0Ks17kWZSbitTZATgKWY46HmmDdu255xwM9K5jUPFTQxlooV45+dyf0GK5K88ba7cTHyr0wx9NsChP16/rW1PLK0t7I5nVgutz1jLKAFVz3yFJyab57rAZpkaFO3nDafyrzGy8SXEYDyvM0n94sSfzrpYNQmvrVZrp3ORkb2JwKueWcr1kRGqpPY0rnxDZRkqqXMjDgEKq/zP9Kjt9dS5Y7rIKBwN7lif5CksLKGRd7AHPNaJsIjwiD8BXRDBUtmZyrr7KK7azL92HZEP9hAK0NIuhNqFqskhY+cnU98iqN14blkiMkMhVvQ1l6XZalb+I9ODo2wXUW4jpjcM16FSFClhpqCWz/IwvJzTkzu9Zs4ptQnfzCsny9/9kVyt9LJZFv3x7gh/nVgeoIPUVP4ibUl8Y3nlybbb93gE/7C5wPrWD4guT5AUuSxNcuX+weEpRlFN8sei7IutN875dNTe0jWobnRZbCMyfabbEqRjkBc8hSeSAM+9dFYXaTRr8wzXmHh+4uLDUo7xYPNVcho24DAjBrotJ+1q6uxbgDivTwuP+ry5GtO3U56sVJX6ne0VUtLl3QB1wat19KndXRyBRS0UxiUUtJQAUUUUAFFFLQAlFLSUAFGKWigBKkh/wBfH/vD+dMp8P8Ark/3hXNjP92qf4X+RVP416nynHOpg25xVcz+Wx2nioAcHFLtBryFFI9a5MZnk9c0GGUjdUkSIFyOTVkPlMYqHPsTdENiheUKTiuhTR4LhOrBvY9a54ZSTI4PtV+LUriEghgQPUVnPmexEl2Lt14UnSIyQyBv9k1jW8Ey3yQMZIiWAYoMlRnk4rqLPxGJUEUsbBuxHIqC5jf7Wl0oZcfxJ157fSs41Zp8s0Qm1uby6LZ3UZKq8bgcEHqcelY2oWlrYFEvLd3iYECSP5WU1q6RqqPb4YhznHJ6VkeLdWhu9QWGCNleDKPI3c+gHt61hS5uazCE53szGvLOxiuB5M8ssZGcMoUg+hxUSzeWMRfuxnnaTUBYHvSDPPIP0NdVn1NCys8ituDsCRwQe1WUuvMP74KDjhhgfn/jWeG479aevt2/xpOIXa1RpPahiMAEEcEc5qzZ3IsJBHMuYGOGBGQM/wCeaz7e7khG1W+TJO0n+XpWsmrxlEKWNmLheBLLD5n6ZA/SspN7NGkazi01uVdS06GykEjNuhcnYB1x6frTGspb2yIeKSOOeJXidl4O3gYP4H8qtO0E2mrbXMkjbTlXVQCP1PbiuqiSCTQrSKGBjAIhujV+mR1B6Bh6kfnUTr8iV97mzlCEm47Nfdc0fhjZS3Xws1exVwssmqeVuPIBIhFbrWMVlqbtKIvtH+rMsa7Rt7+uOn41W8CaW9l4B1iEsQral50bKeSNsJGfQ8YP0qd2ZpgEJ3bc5A5JNcmXNSqV2v53/wCkxPbyrDKa9rLpsTELK7yIzNCDtDsMMx9hn/IqzAm48g8DHrjFVbWFlLMq5WP7xI6VeglZmbJbb39T35/GvbhoevUdtEaMECtsOFPHQdq37PTxKBkY/CsC1mBKEjleOT/SujtL6NcnIHA6VunoeLjHUXwlp7BFjPyjp19aw9RgRASBj6Vty36NGTuwfbisG+nEmTuB56Cqv3ObCe05veOdvEO4nbWPcIFTOeeue1bN020tkMD1GBWTO7Fiw4IINZyZ9Phm7FB0guLSW0vIFlgmXbhj9f0rhvGUbQ6rbpksi2scasRjcFG2u9ZCWZto6buOB+FZmsWEep2bW7ECVRuhYj7ren0PeuWcepjmWAWKpuUPjX9WOJs7ucxiNUZuMetPjy8wiKfxYIPWui0DRLlLZ/Ps7gSqzAkR5Bx6Eda6DRvCHn6lFqd3FLHDEdwVuDIe3HUAGuGM1Ko4pfM+FlLkbTR1Pg7SjY+DZYbqAKJp/N8t+vRAMj6rWqbFPLzGuDjnAxmrcTBtLkdzxvB+bj0rLvvFNnpb+W8sZnYcRDn8/SuTL+ROu5P7b/KJNd83K/L/ADMDWYWgWQcj3auQ0RLnUIL27usNBbTGKFCMZJHLep9Ksa/8R7SbUp4na5YRtt2xwrsyOoySD7dKqQ/ETRxCkT2t6ihwzeXGnzD0+9Xv4bh7MZv2ioSaeqdv8zmSSuWf7N8pVlEQWM8kEc+1XHh/0USH5UI7e1Ydz480iZiRb3xGeAVUYH/fVVpfHNl5CRxW9x8nQOq4+p+bmuiXDmZ30oMmMeZ2uX/EGiSabBaamznzrtcLEEO4L/CT9azLSGW5XDW+wEYYE1UufFkV/dme+e8nboGbBKj0AzgD2roNN8ceFbK2jSXT76aUEl3eFDn2Hz9K3/1ezKSUfYtWPosNQwFKCdatfyX9f5G94V0eTTr631Yz7gkbI0IQgkEEdc/Q+9dcLud3+0LneRtB3Y4+np+dcR/wtTw2uAllqar6COPH5b6cPix4fWMKLPUST94mJOfw31tDhzHR/wCXLOqWJy+TbutTbv8ASYtQWRbguBJkkxsVbB6jOMgf5zWlCs8FpHbWz/Z4IUCxpCNiqo6AAVyZ+K/h0nP2TUx/2yjP/s9PX4teHAQWstTOOgEMf/xdaR4fxsVZUWP67gfI6uUTNEGMkjknAyxxx1/GmNbMgzHI7DrnJUj8jXLH4teHdvFlqQbPBMMZ/wDZ6a3xX8ONg/YtTzjBPlx9fb56r+wcf/z5ZpHM8MlZSR1iPc7cJPIq9hvJxWPdadHNcea8sik9fQj+lZUnxW8ONCirZ6kWBJJMEf8AMPz+NU5fiZoTyEi21ED/AK5p/wDF1lU4dx1RWdFgsZgKjvNr9TQ1EPZofJgQHokj/MDXLumqzTPeavqF2dOj4WCNvLWaTtGMdBjJJ9PrWi3xJ0diwNresjcFTEmD+G6ue1jxNpd9PE9rDdRxRxlFiZRgc5zncc5964nwzmEF7lBnlY6dNe9Rq3Xbt/matlrlghWP7AYTzyJmI/EHNdRZJY6parKqMm7PyvyfrmvK01KxNwhlWfyuC+1Rk+w5rd1DxtbNeWz6bbSwwxx7HDAAt6cA/Wo/1ezVVFajK39eZwQrq9pPQ2df8NyJC8lod/H3K87Je3uTHMhRgeQa9DsPHNpexPEySK6rn5wOR7Yrlbi1k8Ra+sNrH8znr6D1rnrYethpuliIuL8zTlUrcmtzS0e1W+KIq7ifSu/j8JXlxaqoAjU46+lbPhTwlaaNbRgJukx8zt1JrubeJSu0DArz/ZSnPTY7VhY0l7+rPODodxpsGWdWAHQVY0u4hlkAJHHWu7uLCIg7wCPTFcZr2kxRFp7I+XMvPHQ1p7KztIn6lCo70i1d3SQkIuOelVrKVX1G3+UZ81f5isKx1eO5zFPxIODntWzpy/8AExtsc/vV5/EVhVwkZxm59E/yOKvTqUZK66lrWbL7RrE7Y67ef+Aiqi6BbMQzoGb1IrevE3ajMcen8hQIxivocjhCGXUHFauEfyR52IbdWXqzKj0m2QDEa/lV2Gzij6IPyqyUoxXqNJu9jHUQRqOgp+MUUUrjCiiigApMUtLigBtGKWigAxSU6kxQAYoopelACYop6JuPtT2i4pcw7MhxT4f9dH/vCm4p8P8Ark/3hXPjP92qf4X+RVP40fITJijOKuJp11MQqR7j7UyWxntziaNl98V5KkmemmELcVL5m2q8ZwcVK3TNQ1qSxxfJprSEU1SM0rDIpAamnSIZox/CetdBM9sYTsft61xcbtG+VOK0Ir1nUggZrKdO+oO1iKO6kgeXym2noMVAMdj+lTSR4G4dGJbNQ7G7AkVasCYhHHDDPvSA4PcH1pWUg/MMU3GenWqSGmTRTIpPmjAYY3AZI/CrDxwrboyqxkfgYOcnr0FUfY1LBIYnBHIz901Lj2NE1sycIytg9Rxwc1KM7dw/EVECFw2c56Ed6XcdwKnkHipaBQRPvJ9/oK9N06AjS7T+ErEnHvjn/wDVXmMa5kQL91iAPYntXr1u8ZjUgkYODkY/LnmvLzGTio2FVvojVMsmk/DnVbgZLrKHXjpnYM/1rn/DeqvcW00zuPtAbCswzweK2teneL4Wa1IgwTIqc+jNGD+hriPBYZryXK5SNFynqewrjyVu1Rv+d/kj6zJGnhnCR3SNHag7XEhVsICM7/f6U8XHHl8Ek5LY7+grPRvkaR3yxAC/QfyqyjiH5kkySuMr0II5/wAK+hjM9GVNddWaUM6RxksCSfTqfxqzDfPGvuDx6isVpm2uA6usfIIP4ZFIlwRhiSM9q1UzGWH5tzpDeM6s65wAM5OapzXJPpz1zVLLJCsjtjd91e5HrUDThjnkgfe/wq+cyhh0noSyt5rYU/L0GR39PpWcxLsRuAABJ9qlnnEit0X2/pVVU3xB9w5Jwo6j3NQ5HdThyrUa5G1UY5ABxg1UZRy65IHJI6inScL7Gq8hwvHU9faocjthEHEsw2RyeXOvKMD972NFr4qv1JtrueYLnBdMb1PqCQahMzLIjbcematppUGrLLl/JuNu5TjIbsciuHEUot8yPDzvAw5HWS9TZukuX+GGsmS+N00lwrRyqxB27o+P9k5zx/jXlkFvcpIWcMWPcvmvTdLt1j+Gms216hK/bBGwJI25MQBBHoTn8K8uGm38c0y3c6QRwStCz+YrF3HaNMgv1HsM/hXBlaTddSf23+UT46vBJq21i54ZCDVNTWbGDMFyx6HL16RpFtctpUUEWSvms5mK4UDtj15ryLRLy30/V5J7+ykvER8mHztgLAnluDn6V0Fx4m1bxRrdvaWZksrZX3CKCQjIHQEjFfUZ9CSzKTi9OWH/AKREzw+GlVaiuv8Amdhrl9Dpcb6bppJvG+W5uj99Qf4FPYnPPoOOtYFrpk17KsMMZKsACT/CM/pXZaRottaQI88QmctmV2GcknJxVxPLiWQJEFV2JVUXaPqfw6V50aN3qfZ4KhSwkOSCu+r8x/h/Q4tNti24PO43ZxwOfWtcyb7nkEBQc7uxxzxVQXCy26AsU2qQAo6nPFTrIHjEpJLqRnHOOuc12QSirIyquc5Oc9y5EoSIBxtJySF4yf8ACrlvGrBSw43c+lZ8khaRS3puY55PrVuOSRUQSAAZyBnnmtUcVSLaOgitkaNcqDxTJ7RVyynbxziq8V+FIU5yKbPfIVA3E+o6UzzVTqcwwgcng7Tk5pJDHIB2GBn/ABqk9yOWzwWwVBwaja6CsMYUdeOuO3NB1qlIbc3HliSJQNjYz7+tY10qM+FGUydjEc47Zq7cyDy8/h7VnSSoYCA2CpGOaTPSw8LaooNxO+DggcZ7n6UjyK0OMAE8jI5H0qS5kL3IkARWByMcCqQmLMysfkwcH0JrCWp6cYuSTOT12wTTbd7i1TZFKxUog/1bHr+B7fl6VzF9pV7dX8kkJyjqrg47EZ/nmvS5oY5o3t7iMbGi/h53g89fXB6+wrP0m0YNJp8qg3dpkxuBxNFn/wCvkfUiuedqS5l1Plc4wX1aqqtNe7L8zy37Hew6hLAIi80a5cL6cc/qK9P+Fukq4lvp4yJCdoyOgFZOnRJJ8SdUQjI+yrx+EdeiaIYrKIoAFNernk7yor/p3T/9JRw5fNOrZ+Z1RlSIACnx6gY1rNWZXGc801pO1eRGqonuexT0ZPc6qzEisS4vFklZSc5qxdyKiE45rGjWFyzu2Gz61hUqSnLQ1U6dFaI5LxCDp+orcxnCsea63w7qMM0lkSw3tIgH1JFY3iSxW40x2zlgODWD4QnZta0yJmPF3EP/AB8Vo6lsNO/Z/kcmNpKVO7fmeuXuoW8WqzQu4Djbxn/ZFTJKki5Vs1554xWc+Mb7yd+f3fT/AK5rWx4bu5hEqXTHPIA7muzIcfCeDo0mrNQj+SPl8TTaqSa7s62kpkbbhUgFfQnMAopcUYpAJRS4oxQAmKMUuKKYCUYpaKAExRS0lABigDNFKvWgaRahj+WnSDYMmkjbApkz54/OsdWzaySK4DMSQKfEjCZDt/iFPixnNWFxvH1rHGy/2eov7r/IVOHvI8J8NWtu9tuO0sxzWlq+kWslofkUk15xpWvXGmsFYED0Nd1p2oHVYASxwRxXgTpTi7nXytHnmqWX2S8IT7pqrzjFd/f+EXnlMjT8HpxTdN8GWz3Si4clQeg71qqitqXFSZxVpptzdt+5iYgclugFSXOmT2o/eYz7V7FJpdnZ2ZSNFRQOwrzLxDqdu07QxfMQcEjpVRlzbFOPLuc2QQaVdwOQaGfJJNTKiqAZCV/2RyT/AIVTJLFqpkibJBIbp3qVoie34Vb0yNZYpWWIKgIGQScn8fappY1Cg7xGG/iIyxHsP61zylZmbeplG2lfIjjZsdQozioGt5F6xsPYjBrXbUY4YltrYqqg8knqfrVKW+nR9r4lTPMcwyP/AK1VCcn0NIplMxtnkEH6Uqrz/wDXq+i214hMLPbuoxsdsofoe1KbS4hlEcodCQGAI4IPQj1HvWiqLYpPWxUZGVMY6cj+tIucfjV6RH3hMKOOoUUjWwUj5UIxnOKTZumkxlowFxHntIrD8DXplhdA5leXy4olLyOW6DuSewrzy2t185HWMKVOcj1rbuoJ9U0+eGa5l8qYAMFOMEHIOBwea4cTR9q0ilD2r0Oul16LXvhF4lubcFbaLUEgiJ6soaA7j9SSfoax/BgCWVxIDmQsEGRnjuaNNsZ9E+A/iSO4WOQjUUdcElXUtbjPHI71k+GtYgl0y8e3zAIwolidi2NzbQVPfk9+frXFgaXJ7ZU9lN/+kxPXy6v7JqDO/lf9xhEVQ3yndy2B39uf51W8/wAt9pX5z0A9qy7bWPtDiVpFBOMEnOPX8TirX2+O5upCioE+4rP0XArvVQ+np2aLKNuLPngDcQxAz/jUnnEN82VPXp0rLW5R1d2YFtwIOegph1APJyxZT0qlUOj2VzakvpJmyTntzSliqkknkcgVmrN5cfzKQzHcGz+FCzs0mXPH61oqhHsV02Lj7cBlyyn72faoXmZHxtxg5xj8qgeVA5yWVAOM81E0pZAWXBY5DHPNL2hpGn3JN+9iSRyeB3qGWUA5UDOcgjoPao5XCEplTzzjmqk1xGhfBOeML6UnM2jFbiNKVfb645PatrRL1Ir63lcfIHCuM4+U8f1rlZ7lQnJO7J596ntrobCoIOOOta00prlZw4+UZwcH1PZr8WUHhu9ZYQsBYeaCcgnKgnOOmMflXhsl7c6/rc2oSsIoEci3hRcBR7d+e/qSa9O0/UDP8LtUnS7je4O+JzDlgjkKoXn2Iz9a4G3gtdLsxvZECqAXdsfmetfP4OfJKura87/JH55U0svIwdMsre/vtVNzGflmzkg7lyzZ4ANd14R0bTbfz9QihIAKwxg5BcjJdufqB+deY/2tdW93enTxHm6l+UumSOTjCnjPPccV7nZWqafpENrgM0USmR88ls/MePVs/nX2WdU5LMZSb05Yaf8AbkTuyWnebn2/VlsM0ckqAv5JAOCPUdfrVcyESMjEsFTauO2Tn+tOSQiNpeRjDBT0bB6frSEJLMmSVLHkf1rhufSJWepZgZvsxwUIVsYPJ5HanrObdN4bIdvmXqrDFV4Ts8wqNrRphR2Y9/0NNd1YAoSRgAfX/OavmIcLvyJkuTkfOCeSMe5qzb3P7tj87BW4Pp6VmIGa5KjkZPAPapIpnRGiTeN3Y9KpSCdJNaGut+Q2TIQSo3D+9ST3ZLHD4OePXpmsbcRL5bNtxJgnPT1p3nI0rDluCFI9uhqucj6tFO6NTzScMTkHqwPek+1KgKdyMkeoPvVBp2ZwgJUBuQTxxUcrAAOzBDtO0jvxRzAqK6krzlsoWO0849KpyyKzYYnIbOPX8fwpPMJjZv7o4z6VWMgmmyQASM4HSk5HXTp2HXE4wmV+YHnHf0qAP80gUZABb0/z1ppkKyKOCFbJB5/Co3Yee7MOvzEDgc9KhvU6owsrEsUieZDgn5COT1Pfp+dbOmyh1K55B4z2Fc+jBm5bG0H8eODTJdSls7Ka7i+VoCjsuPvKCAw/KscRTVak4f1oefnFBTws/LUx2jmX4qa21qq/u7VXYeq7Ys/zzWvf6pcWcAmMZAU5JWuT0rW7m48c6pfRooa4tjGwPZfkH5/KK7TCXlk0bc5GMGuzOE+agn/z6p/+ko+Bp1HCXMtyOx8XQyqMvj61qDxLbkD5x+deX6hYSadeMoyEJypoilYY+Y5rxJQa2Z7MMbdanrMepQ3QABBzWLrOnXEU8d1FIRGDllHeuZsNQkhYEE1rXeuy3Ft5R9KzjNxdmP20Zbjtc1WNdO2ockjFUfBNgX1eyuG/5+UYD/gQrNNrLduA2SvpXU+HE+y6nYRDjM8Y/wDHhWlRS+rz9H+RGJxaklBHQeIDBHrt28mAflJJ/wBwVT050ubk3EalYsbIgeuB1J+pqv4xl3eIrqHIVRs3E/7i1T8LXq3UU5Xjy5iF91PQ/wA6OHoRhCk/7q/JHlYtv3vU723+6Ks1m21wCAM1cWXNfbtX1R5yZNRSA0tSMKKKKBhRRRigQUUUUAFJilooAKAtGKkUZFJuxURASBmkY7qc/AqM0kU30FV2XoKkjlYyoMD7wqKnxf61P94Vz4xL6vU/wv8AIKbfMj5lv7KJoDj5mP3dtXfCl5dW05gaF2Xs3pWfZytA2yf7vYntXRaXc20RO2RTnuDXjX0aPT5k2b97qUkcGTEzHHAFc9H4ku47k5tXVQepGK1X1O14jaQZPTNWYGtpflYKQa5m7bocvJnOa14ovZrYoilVYYJFcU53MSTkmvUdS0qzuYCEQLx1FcBqGlmzudzYaHuc4relNWsZu99SiqiNA7Abj90Hn8cUzPOW7mnSbnYsxJz3puBjnNWNGnZaqbSzmgU8sQynGcHgH9KryXTSk/PuJPryapdDTvLduQjY9ankje4+VDi2481MsjNEUkyyryp7r7A+ntTUi3soeRVbPJPP8q0YvsUO1REZ2J+Z5OB+AH9ab7ItaDY9OlltxJFNEIh97e+0r+Hf8K2tKnMdqLO6WS6tQxZVdtrIx7oeq/Q8HuK7nR9C0W4jlkMTT+XEAN5+VST1wD6Cqt9o1jDKzx2xTgnZ29uDXO2pL3jN1Enoctc6W0RE0b+bA3CuE2kH+6y/wn279QSKp3MflsmOMg/hXTXu6zcrCEkYJhkblJFA5Uj+R7HmsOYQyShoWLxMu5C3XB7H3HT8KcLuVmVKa5H3IoNqjpj3PrV23nEczDoMnIPeqwhwuR27V03hLw22r3RvrgAWVoRv3f8ALV+oX6AcnPsO9KqmtTKNaS2OhvtAmvvg/qlhYZmmu2jmjRmC4O6JsZ6H7vtnpXlep6JrfhnRraK4sfIs3kDTzIwYyyEcBsE4VRnAIHOT1Ne139xLfeB9ZTT52heO4WJJ4z97BjLYx25ZeK8X1q98SX1n9jujIkJ+/EqlQ59/X+XevJyudZyqp2s5u/faJ7FDC4mVpqO2/wCYllNJIqgMwPUEGr8d3LDhRgh1w5PJOD2/GsbQJczfZZwUlQ4KkYNb91axhioOGHU13S92fKz6bBzc46EL3wxtXO49MHp9ferCXUcEcbA5cjkk/wCHtWO8Gws24DtyaoyzMSBkgD9apRudUsRKG51L6iFj2ljuzkZ71ZXUDCVjdgM/MdxAyPrXGx3GASzHIHAPenNdPKxbJ7cmnyMSxlzrBftPJ8x2qe5pzXoCEh/lXjk1zMd3MRjd8oGOe1SLK5KsfmHXGfT1pWNlitDfe9A8vPDN0AGOKzbu++XYCCAc4x3/AMiq8ty9xjaip9OKrqGw7vnavP40LzB120OMhd8ZOB6DvUtp58l1HFEryPIw2oilix9h1rUs/CerXOzMAhjfG6aWRNqqe5AOfwxzW9AdO0NTBpoa5uCpEs5HLexPZf8AZH45qZYlU9I6s8XG46nBaO7Zuabp50T4XawlzL5kj3glkWNdwVi0Y2A9zwOemSewzXl2ozSX8xwjMEPyQryq+v8AvMfX2NeoRtLP8K9ZLsXdrpfujtui4Ht7/jXmzW7K/kwxybs/NIpx+ANeZlrvOtOW/O/yR8tV6FLw9p/2vxFDHMuwpdJuU9RhskfpXuRIkhbedpkbvxzmvHPCFtI/iOUpGzeTLuYKpOACck+gFerQ3IaAoBg7gQPTFfaZ5L/b5ekP/SInqZJ/Cl3uK5Z1Zc9yqt0oV2ZQYTuCqN/rg/8A16WQLh0BIVkJUds+tU4XZW5AVhgHPNeRzH0UUpItNMEmKd9mePX/APVT4ZALaTa6ggnr1GDxVWd08wTDaWTHB9KtpMgszH5YLo27jneDVcwSWi0I2uHVwNgyVOfx6UyZiiBgfl3Y5POahnEjqkjfKRiP8uM1FPIRGQ5JZiGww6g+9PnNIw1VidphvUkknGN2cUsUxRmUHlunc1EskLsqncyAZOODnFFuVDgsTnbySvGarmKcVbYtySNiSVs5ZsEjjmgzPNCm8BguBwOo9Kim+6ytyjDcxUY6dhmoVmZkGB0IAPXNLnIUE1cWSYiOQE4UnK+tVEkJd2GMjGPYCpHfyYSG5BXj+lVmfYgi2or5OSaHM6YRVhGlaRpJgNhb+6eOf6U2Z0jSJQQ7kHPr14qIybSEBCnGMjuOvNU3nMUhkJzjJXPrWfOb8qLsUxEbs3XbkD07YrLlud9vdws+Q0TfoM1C97gMqsRtAB9/xqja3Aacu4GxUOQe/wDnNaU56nm5nUSw815P8hnhiHb4wvkdCpFrnBGO6GupnvRatiua0m4X/hOL6TPytbAD8o/8K0dcddgdW5FejnKvVo/9e6f/AKSj82tcj1C8hvAA+M+vpWWIAsmByKyZrs7yc0seqsjivLdK6NoNx2OmggJxhTWjFYkjLLWXpup+btBH0rq7SPzyiyyBMjdsA+Yjt9K5p04U1zTehXtZbIrxW6xLkDmrGmFRr1gvV/tMfHp8wpZ9e0HS8xSyb2BG/CeYR7Z6flUOk+I/DNzr9gtt9pFxLdRquIiFLFh1yePwqMRjlLDyhTg9nrbTYmFJ86lJk/ju2kfU9anGfLihR2YcbRtUD8STXPeEblvMvCC3lnbgEenA/Stf4meKJft994dgtIYYt8b3E/V5jsVgPYDIH4Vg+Ck8y7uEYf8ALEH261llUWsLSa3tH8kXiWm2ju7O4Zjwa3rYFlBPWsC0gVHAro7VcKMGvs8K3KF2eW9y0oNSBRSLUikVq2UhPLFGwU/cKTcKm7Kshvl0bPrTs0Zoux2QzZRsp+aM0XYrIZspCuKkzTW5p3CyIjkVKpGKjIpyggU2ERzHK0zFLRQhS3Ep8X+tT/eFNp0X+tT6iubGf7vU/wAL/IdP40fMF9NGYyMjNRac+5jH69DVGeyuEJ8xuhqWynED4fjPevG5bR0PStY17mykdB0Hoc1ni8vLGQhZmBHYHIrTOoL5AU4zj1rIupBMSwqY3e4tzWttfvJh5LSohYYEhGQPcion0xbmQyPetO46sWB//VWGJgnFPE/OQSD6inyWd0JpmnNpkMTHc7N9CAKpSxxpwsY68ZJNaujQPq2+HzgjjAVnGR+NVpoJbeVoLiJoZFOCGGCR2P0NJS1sCuZ771xhmXjoOMVEQxI3Ek+9b9tp0U6HdgDoPXPtVS8017JtzI7wn7sjDAPt9aqM1excZXdjPWLbEX2n/CnIjMAQ5FOZGCnk7RzToAQgYYz719BhMRPC5bOtSspOaV2k9OVu2qZFSznY3bIXqQoE8QXtuSAdiswx+TVdewvZhz4mvH4+bcW/+LrHsIpbmfYnJPX2rfj0yWKPfK21QMkn2rjlnuNX2l/4BD/5EycFeyMq7sLyONpTrFxIVwPmLD/2as9IJg+z7fKm0kA5PHJ9/wAfxq/qF/CjNChLkg5PTGcf0zVdrlTIZSiZznp3oWe47+Zf+AQ/+RPUoZb7Wl2d+tyeHSruVfl1WUD8cfzresdA1l7KSKHxLfw2pDExKXCtxzkB8c4/SsGK/IbqMHnivRdPuVi0CQnHEP8AMVSz7GveS/8AAIf/ACJ6uFyXDxV5+8/Vr8mZ2n+Cdbn8Mz3cfi+/ihWTBtlD7W+7yf3mO/p2qKLwVqDFFm8Y3aI3O4KzBe3P7wc13WgSrJ4Gu+mFn2/qh/rVKXy3jUBm8wDHI4HXP9K4sBxBmFR1ryjpNpe5Da0f7uvzOqGXYdymrPf+aXZeZw3iP4ZXel6adYh1r+0Jch2zFtYqf4g2455HNcXay3F1MYptQuIpR2Zif1zXtaXcsFvcWQfdDMMEehHPFeZeLvDYsmW8tCAjE8A5KEdvoeo9q6JZ5j1vKP8A4BD/AORM5ZVCknNXdn3eq+8ypNOmJ51CRj2zn/GqktnIj4Fwzn1wf8alstTYJ5UmMjrxVpnjcZBwTWX9v5jF6yj/AOAQ/wDkTaOCwVaHNFP/AMCl/mZEsbxLvMhJzjFXABs+Y4HYDqaivgvkrj+91zU+fmHA/Ct80xE8TgMPXqW5m5ptJLbltskcuGgqOIqU47e71b79x8YHQDnPAqwI5AQjcA84pkbqHyqqD274q5CmRv5JJ5Jr56TPVhJkIRmerCwqEzyTnv0qyLYs2SABnJOOlStH8p4+Xrms+c6FJFKBEgu0nbcqqeiHGffFdOL2zaEeXPDGNuWDOqkADqQTnvXK39xHbDLkbj0HqazrK5s/tKy3kElyN2WXftzVPDe2XMfM5xKjGa5V73X+u567ZzxH4YaxIj+cou1z5JBycxd8/rVXw74XvbyGO8awgjt3zhZpGLv6HgdK6XwhJoFz4Qnezt2jsDcfvIrohgrgJ36EfdNasuu6TaL813GAvGN44rgy+nTi6yn/ADv8oniV6j922mh5x4K06a41rxxbRzGIrcMpSNRhm3TYHPQZH607SNXE8OHIyVByf8+tTfD3UMeLvGEsClkmvRIGxkAb5SM/XNcnqXmaRr19ajhYZnA90Jyv6EV9Xn84/wBoyS/lh/6RE78lqqMpRfU76K53yITt4GMdOD/Wo5591yxB4PysT2HY1x9r4hIKbj84wMjmtgaik6F1GVY88fnXkXPpY1EndGkLjau3YFYDB3HIIzViG7je33DIJOCPp1//AFVitMzjKgfKcucdKf8Abg7RqMZyTtDY/P8AClzM1VdOxrysPLZMsQ6/Lk/dYciqu79ySE3ADCv6VU+3KIlQuTzxnt6VCb1drru+XqeM0+expDEJbltbp1VMuGUE5B6VajuEEa7ifmGFH41gLfwsZd4AUEYOemaWHU42Cx9SDxmjnN5VoM6Az7Wde23gZqETeXh0xs3ZwfashLoPO5aXCnnGM8DinT3caoxDMcA9TjH4VPOZe3inYuXF0zblU5G7txmqRn/d/KWDkcgmqX25JD5hJBVeB1zWdcXMkhyy/L2Bo5jVYhLRGhNecBN+P4iAfaqb3gmfaOpbkH0/yKqSTnYq5IA65Hc0xYiqb+V/hHHP+cUXCVZvYkeQMXReeTgk/jVW6n+z2zuhwXYKo9up/kKVARJx75qjqsn72OEf8s1yfqf/AK2K1geRm9Xkw7v10G6bfmDWJZ2OC0e0/wDjv+FX9S1Tzo9oaufjyblsDt/hV9rORoN2K93OEvaUb/8APun/AOko+MgkUZJyxzVdpGzmrPkENtI5q9ZaO12wGDivM5ktzXYteH5/Nuoo2OFLAFsZwO5rf1nxBLbxNZWr4kbmeVRjGew9OMVJpOgpYafqGpltsVnAztIehkIwij8SK415NznLrk8t15rjqQjVmm9kJRs7jpC0jD5iAD06Vr+Fh/xVui9f+P6Dn/ga1jqY+MsT6YFbnhfd/wAJZowxtH26Hp/vioxP8Gfo/wAhr4ka/wARQD8QNTyCSPK+n+qSrHguMwi6nZuGAQZH4ml+ICZ8d6mcD/ll2/6ZJUOlXAtYkiORnkgnuayyl/7NSfaMfyRGI1lJeZ3lqyu2c1u2rDaBXGWl6vHNdBpl2Z5NoBKgZJFfT4fF01FqWhxSpO+h0AIpaznuDA+GPy9m7GpVvFx96u1Wkrxd0RqnZl0mkyKpm7Ud6VbpW70NJbiLdFRK4bpUgoAWilxRSGJQTilxTG60wHgZqZYuOlRR8GrO4Y61EmzSMUQum0VFUsj9qhzzTjexMlqOp0f+tT/eFMFSR/61PqKwxn+71P8AC/yHT+NHzPPAzuEkOMnnih9FhYZjyCO9LqF+EcrjDDtUdtrZLhXUAH+KvChKXLc9Dm01M+4iktzhuRnrVZmBXFdctrFex4IB3VmX3hyaFS8fI9KIV4t2loyVUWzOYYEtV+y0u5uziJM1D9nkSbDKc5r0HwpDCsClyN2eRWs58quOc7LQyvDulXlhet5seAccg12V/oNrrNoFeNEuAvyT7eVPYHHJX2rUS3tiM8UjvHBn5sCvPnUvUTIUm1c83mt7zQb0W95HyfuyIDtb6H6flnmuy0ixhvUSOTDxSAh2JyHODxz2znmptQvbW8s5LWVEljfqjdDXOtqkul3BK2QuLXG3ygxTaMcEY447ZrZrVNF05WkmXtf8IaZDpV3cWZeF4Y3cLkurBVPGD0+uazfDHhzT73SYby7nLFyR5QOzBDEde/T260y58Tz3ukXcaiaJPKdGV2V2IPAAIAwOmeK6nwLCZfCViHlPlgyEp9Hbj8+a9jmnHJ5X/wCfsf8A0mQ40rzte+g5YrGEbR5EbBgNowDz0+v865vxNrdtFC1pAFYupGB1Qg4GfxB46/Sk8aXktpemztZnhtyozGhwCe/SuIdjmvHppy1OyFCNN36jh8z7iSSTyTSvLUaMCzY4AX86aWG72rax6tGdoliGXHJzntXc6drJfwvcQNtyGVPwJ4/ka4BTk5XpnvWhaXbpGyA4VsZHrjpUu/Q9TC1Vsz1Dw94wj0jTJLCfT47yKV/MAZ8YPHXgg9BXS2vizTrkNjQ7cOP4cqc/+O15DDdBVUHr3PrWzpepmC9SQOQQeoPI/GvOqZbhZ1HUlF3e9pSX5NHdDCUat21q/N/5npf/AAkWng5/sK2BB65Xj/x2oW8Q6VPG0Unh+zaPK5RgpB59NnasGfER27lZiucqcjmqpwJcLlsZOAKJZRg+z/8AApf5jjgKEls/vf8AmR6j4y8Padqc9o3gHSJDE5VZF8vDDsR+67iqcXxH8Pudg+H+lqQeRuj4/wDIVZ3iiw82CO4CsrhRnPdTnBrib1CF8+FtsiDJ9x3rJZThG7Wf/gUv8zycfg1hvfp7HV+MfFOla3pMVtY+GbLS5UnDmaDbuYbWG3hF4yQevaukXx94fbp4C0z8PL/+NV5S18bmMRumHBzkHiteK9tnT5JE/wCBHFe3j8ro/wBk4WDi7KVT7UuvJ5nkUKtKVebfZdfU9Hj8b6AcE+BtMTPT7n/xqp4/GuhvwPBmnDHun/xuvPY7q1XBedcezAAUk2vWEAyJA59EO4187/ZNBuyi/wDwKX+Z6ClQiryf4npJ8aaIqjPhHTwOuMpj/wBF1RvPiNoFqrD/AIQ7T5CP4Qyf/G68uu/Ec91lYF8pPXq1Z8b7mLsSx6knvW9PIsPvNP8A8Cl/mcOIxtO3LRV33uz01/iZ4flbMnw90tj0yzRn/wBpUq/Ejw4Onw90of8AAo//AI1XnKSZBJAz7CpFnYADP4kZNdH9j4RfZf8A4FL/ADPLlWqN3bO+1f4kQaj4em0fTfD1tpcU8ivIYnBHBB4UKozlV554H5WPDniTw1bJELzSmhulxmcDzAT689K4vTfsV3K8NzsgLL8twXIVD7rg5B9qvXOnjTY0mmmiaB/uSo2Q34dfzFXSwtChF06Std33bu/nc56jc37x23w4lt7vxF4snjfckt2rx5GCyl5T/LFc54r1m11fxTdvbRGJoMQupx8235d3HX0/KuMXVLizmuXsp3h85j86EqcZP+NVLa6a2ulmHJHUf3h3r6HPcNfHTl15Yf8ApETTBz9lNTex0Lxkcj8amtb2SDHLde9SJsmiSWM5RhlT6immLdkYr5/m6M+kfNvEs/2izBtoA9c802e8lZg6nnjIHc1XWEgfSpEQ46cH1oujHnnFkxuJGIKscHkjPSlaeR2LM3J+9TUgJbHNWEg9VyRUNolVJFdW2tyMgnOTT0BBq0LQ9egoNtjJ6cVPOjaNSTKpDedwxAz3qZ3Z125J4wTUqw7scHIHNH2YA5Prmlzo2jKRXCEpjOM9TRtYr83LVdEQK8r0oWHfklcenvS9odVNtlKO38xih6DknFOuR5jARjCrwM/zq8IvLBIGPr3qCUjGT1NUpXZ2wjd3KHkkEKoJPJIAzUDeHry9ElwqFerEtXa+HtNSOA3c65eUYQHsnr+P8hUniZozpLWySeUspHmFepTuPxrpgz5TNsV9YxCowekfz6nkkRJuj5eSSMCuitLS4eMGQFVI4yKf4X0+3uPFU8ZRlijg8xVPf7uP/Qs12l0kVvepZ28IlvCu7nBSEerepx2r2s9qcs6N/wDn3T/9JR47SUml3Zl2ug2Vr4fl1e9gklCTLGI1bZnI4+vNLDNpEUO+eb+zk/jU/vJNv+yB1J9+lW/EOrR6VZq0rLNO/KKx6n+9jsBXBx2l1fSeZI+0O247xyffFfP0put770RpCLept+KvFw1e2h0rTLZrXR4ju2OwLzv/AH3I/Qdq5YKOgPI5BNdTa+GIXXa00mW7jAx+H/16kk0u3sEMMaeZnG9pACT7D0rfnjFWQ1HmdjmY1HXofSuh8LgL4p0fGeb2H/0MVB9hhIAjzHJ0wRuB9MntVrSJDp+uWE06SfuLmKUxgYYgMDgA4yayrvnpSUezCUHCS5jrPE2mnUPiFqO5GaGPy2kOcAfulwKy77TAJS6Ag+1emTw6FPd3N291KJLhlZ8IR0UKP4c9B396oy2PhlmIe/uQf90//EV5WCzB0MPCm6c7pJP3X0QqlPmm2mvvOH05AuJLhysSnGB95j6Cuy0C6W4aZijKiYCKTwAfanLpHhfHF9dY/wB3/wCwrT0/TtGgUy291cMgBByOO3bbW7zGLfM6c/8AwBlRp+a+8lu7dLiDy+AOqkdQRXPF5U4JOR1rsVhtJQNskh2nrj/61UJ7HSvOcyTzBs5bA/8Asa2o54qSs4TS/wALFUw/NqrHOedITya0rMbsZqy1nog63c4/4Cf/AImrdvFpS4EdzKfqP/rV6+GzmnJczpVH/wBw5P8AQ46mHafxL70PiTAqZRUyLa4+WRj+H/1qk8qEDJZsH/PpW08+ow+KlUX/AHDl/kEcLJ7NfeiCgipzHCP42pCsH99v8/hRHPKUldUan/guX+QPDSWjkvvRXpCuasbLf++3+fwpdtv/AH2/z+FP+24f8+av/guX+Qvq7/mX3ogXg0/JNSbYP77f5/CnBYeztSedw/581f8AwXL/ACKVB/zL70VmFMxVtlgPV2pNlv8A32/L/wCtTWdw/wCfNX/wXL/ITw7/AJl96K4FPj/1i/UVLtg/vtSqIAwIduOaxxGcRqUZwjRq3aa/hy7eg4UGpJ8y+9Hy94ghD3OY+q8GsNWwSDwa3dRvoJ7h2U8msG4ILEjrUU7tWZ0RRs6PqTW8oRjlc8A12ovbea05IzjpXl8RdSDzntWxY3NzJKseSA3GfSsa+G53zImUNbnWx6XBcJ5wA59qrqo0+9Plng9q2LCJYbUAZIxxVW60uS7l8wMEx0PesVNp26ByNEN7r7W0O4Lhh71RstavNZLjhEXgnPWotW0xghDSEn1xWdpVz/Z7NEQSHPGB3rWKhJXW4+VHT2Vm0VwJJDuzWhqVun2NmCjOKqiw1OaGOaHYMfMUzyao6rqE0UbCZWyOorPSo9GXyuK1Ry016EkuIxyroV/Gux8D6zGmm/YHO1l3FcnqCSf61labpEFxoOoX7oDIIJGXPbCmsC3abTGs7sZ2TqWU/RipH6frX0Lpp5PJf9PI/wDpMhQk1UT8jW8Yz+brcg3ZwF6fSuaZueelaesXC3V55y/xKDzWYRXj042ikdnNdiDvxT+AuW60LhUJOS2cYqNmy3P5VZ20noPXk4JwfSrETkDp+NVowck459atxbQhdjnHp71LPQoysXIWNaVo+2VccnPaseBsvg4GR3OMVfikWNTtPz8dBWMz2MPVszvRI0MQUgMeAzEZ7dvSovOC4ZQc7cHnqayLW932kYbG4DHJ9KtLMqsR5iOVbGUOVb8e9S5nrR5Wr9yxcFTEyzLgMucEdQRXn97mN2Uj5gcEnuK6+bUR5u5vnCjaqk5z2xXK6tIHuHk2gbiDg/rRDVnm5k4umYKLslZfTp9KqbmRuCQQauZb7S4PQjIqK4jBUOOo4NfS4l/8JuG9Z/8Atp+etWqyXYYGR/8AWIM/3lFL9nzjYwYHv6VDnjrTkdkYFThhXlW7Dv3LEcewHgdanUnAA/ICpbW5jusK6KJfpwauLtHDooH+6DWTnbRoduxSUPwQh9sClCvnnj6mtQlGGPkK9128U3+y3nG6325/uO2PyNR7RdSbFO3keGUOEDfhmtNtThkaFbuJZouVkTkHB9COh7irJ8KeILGBL9dPeWPbu3W7rLhT6hST+lZEnmSXgRovLnLDhgQR6cGs7wm7p7ESWpTuI4hdSRxSb4g5CORjcueDUEqNE2Cv4nvW5bWGnvPqEOqan9knifbGfJaRZGBbOdoyOg/OqDPGrGJnSVFPDgHB/MZr6vNMHiq+LcqdKUlaGqi2n7kdnazMoSSVmTaLqq2sv2e5YC3c5DH/AJZt6/T1/OupMAPI/MVxMsVuz5QkDuK09J1l9P228+ZbX+H+9H9PUe35V4eJyPHy96FCd/8AC/8AI9fBY+EF7Oo9Oj7HSLD7U8QjpjA9DVI67pwPE/8A443+FSLr+nY5uDn/AHG/wrheT5n/ANA8/wDwCX+R6cq2Gf2196NBYguOcCplwMd6yf7f03/n4/8AHG/wpra/p56XP/jjf4VP9i5m/wDmHn/4BL/I55YjDr7S+9GldXcNpA0srbVUZNczP4zXcVjs89MBpOT+QpupX9rfRMnnnnp8prnZ7YCVTG4YAdQMc12YfIcZb95Qnf8Awy/yOarj0nanJfgdpp3iKO7GJYWhfOOoYfnWykqPgjBrhLN7e3QDzP0NbVtrFpEAGnx/wE/4VlWyLH39zDz/APAZf5G1DHQek5L70dOOelOC45A5HSsaPxDpoHNxj/gDf4VL/wAJFpZHN0f+/bf4Vzf2Lmd/93n/AOAS/wAj1KWMwy3qR+9Gi5znP50mmwwX2sxWswJTaXIHQ46A/U1nDxDpOFZ5yyZwY1Vgx9ycYA+nNWtJ17QYJsy38ccr8PcG3fAHoAqk1f8AY+ZpaYad/wDBL/I58dm9KFN06Mk2+q6HcSBYoHupxtt4sbgONx7KPeuDu1vfEuqui5RN2ZWH3UHoPwq74m8Z6VdvDZWN601rFjEpjZQzEcuQRn2xirlt4r8LWtuscV6FwOf3EnJ7k/LXXHKMxjH/AHed/wDDL/I+dU4UY+602zI0+ePSfHmqTMmY7ayU7D3wIgBTl1z7CzXTx7ru7bzCuevp+FYuoalDe+KtSuLFkmgnhRQ7gqMAJk4OD1XGKYh2kqGLFxuZ2HLdvy9q6s/oNTpQqKzVOmmnp9laMMNQc4uo9rkF1fyXt89zJh52PMrjOPQKOgA7VNDeSRLvky/IwM/MarizfzGZeUzx7mmzq6sNy4PqRXje7sjujTTR01tqpmjUgbfocnFDyCRs9vpWTYbhF6Ddmr8e4jG4gegrCdkxQw93fYeyjjjHPc4qfT7t9OvI5/JjnjXP7qXBXHr7H3FVGAyCPw4owcDjnOPzqL3NvYJK256jFLpl5aJNA7ruHIDhtpxnBGKrXNniMSx4kj7sg6fX0rk9K1Cez2pHl4nyXjK5UgevvXVwlXPmxO/ADGHOxh/PI/zisliZU5WlqjzK+Ecfejt+RUZ9mK29DmMjypkbRHkcdyR/SqBtGmBYxNHz0b+la+h24gWYn5ckAuTwoHJr0XUjKndHNSTUtToLWBY7bOCMjis2ZIjNKRyzE8mnTa5EsZFqpl7B24Tj09ayDehcvIQ7ZzknFcMqkJaGk5pbFn7MjhgBzjORT7SEBmUckfrSWEryRtcFG2n5VBHWtXTLR9zSzLsLH5UPYepruwGKnhZXXwvoRKCrKz37li3t/LjLty3p6U9ySQPTk1K7BRkDGOayXkmaVlLlY2OOn9amviJ1ZOczWEVBWiW8nJHXHHBphbmqjvHDcRRPzLIwRY/oM5/D/CrBFezlU3Kk0+jOPEpc90SDmjFCcUOw9a9JtIxSuFPHAqEMB1NP8welRKpFbs6oYWbVxTiikwG5Bp2OKpNdDCdOUXqJRS01jgUzM+RDITzmnwxyTOMKTUr2QQ/K351s6YsMUShwPcmvn5TSV0ek3YfpekvJdRpKoCtXZ2/h22ij3hRnHWnaPpcdwyMhzxkkVuTxtbRlAO1cs6jvqK/VmK6zW6bU24HvVaXV4rZT5zFSKZqN0YmG9ioPAyKo3Wjz3tqZN2ARwKiUYt36A5X1Rm6lrAu5D5SnHqaz43MM8U5XKqwYis2V5LG6aKTqDzVsXAePOeK6eSy0GeraTrOn3FssiTJ05GeRVXVhaXCu4CbiK8wS6kgfdDIyN7VYj1qdnAkkIFckcHyO8WVUqymtTXm1M2FleWmCEljdRjpyCK5u4vTLp1ta4yYdxHPqSf610Mojn02eQ4Y+UxB/CsA2O6wiuVPJzkfiRX0dF/8ACRK//PyP/pMjBT97UpxSmaIE9V+Uj0p+O/emY2vxwDTxXmM64scudhGRUWOenPvUoAPWmtjsB9ak7aUxFySf51bgKkHjOOlVV9wT6VaU5UADGetRI76UyRBk9QB3JqZGdgSoyoOMio1AKjnC/SpE+VTtA49TWTZ6FOoaVvcCKPyyMuxwKDebVbcSCOi+tZ8fA3vzUZcH5u/p6VHKdqxLS3JrmdmChep5xn8qzpGYMc/McenSrI+aUnd2zu6VC/3Wf3zWkdNDz8VWunKTKBiZZfMPTGKjgbePmwc8HNW2YGADvmqskIiLBWyD0r6HFf8AItw/rP8A9tPkFK9STHR6cHmKFzGO+ecVFPbzWN1La3EeyWJijqw5BFb2lJ/aN5bwjAlm2op984NbHj61h/4TLUgBuV2RwT15jXP05rxlN81maysjiQxA9K0rW7En7uY4b+F/X2NUZoGgcAnIPQ0imnJKSIvY3E8sNhhhh6H+lXYmkDDYd3061k2k4cCGb/gL+nsavx7omwucjqD1Fc01YtPsdjpOsvb2axl/K8s8N3PfinX+qW2tbbO/jeaPORPu/eRkc5U4P5dDWbpF0kkMsNwscqMoIV/b+VXtJtLWTVlUyfZgQcNjcB7c9PrXAqcVUbtqMwb+1kttZS3vIYGichkm8kHzU7HPXtgjPBGKtx3mk+H9XEV1o8F1p8v7yPzYFMkYPBGSMnmus8S+EXv7GOazkP2yDIWJ24lB64PQN6dj0968v1y4vLm6WWdC8yLsclcHjjkeor06Ves7RjUaSW12YuCZ2d1L8PdSieQQy2cnXESFc/QdK56Z/D0Af7DZTTvghXuX+Ue+BWVYaTe3iCXYY4v7zDr9B3rTNp9kUeXDk/335J/wq5YqtHRVZf8AgTOvD5TXqrmSsvMwJIbhpPMWHH+6vy/4VNFdrEMTW9sSPYVYvJrqQnfnBHYVjyRNk1p9brTWs397/wAzvWXyo6t/ga41awAwbWD/AL4WhtQspB8tvAPogrB8vk5pPLFP2tX/AJ+S+9mVSk30N4XFsf8AljH/AN8CkkNvLE6qiIWGAyqMisWKTYwDLvXPIzg/nXrXgbS/AviJVgW1kOogZNtdzEs2OpTGAw+nPtT9tiL6VJfezKGGUnrZHBBrYYHlpwMcqKsRvYou6RIMD1UVq/FTStL0jV7OPSIUgja3JkSPpuDdfyP6VxNoC2UP+8v1pOrXav7WX3sbSoz5XFNnQS6tpsS4isIZW7HygB+oqrbXcE2pwy3cMa2inJighUZ/Hv8A54qh5Xm4xw3oafChUlSCCOMHjFUq1SK0nL72Y1a8p6NJL0PSrG28LM7zwWCyxK2DNcJm3hbHAk2jf+OAKmvfBU2tSecNT8MR26Asq2caQrj6gZP4muBsLu5sJDNbzNGzDa2OjLnO1h3HHSu4RvA2p6I95dwjTtQIKi3hZiMjoRxjB9655YrExek397/zNKTpNWskzA0mxsI9RBn+yTKjkbMK4Pb8auag2nXgkgsrG0igj/11yLdM5/upx19+1Y7vGsS7B5cH95RhnPov+NNur5bGHym2mQfdhQ5WP2J7mq+tYiWvPL72ROlTlUXYsCOC3HmeTHHGo6YxwO59aqtc3GqXCNa25EcQKmVjgHNVbaaK5fzL6SWUjhYx90VsLfxJCEjYoR2I/TFYVJybbk7vuz1oQ5ocr0j/AF9xctNDurhMm6tY8HGCx/oKsyeGnHytfWsvHA+bH8qzTqZfjcPr0pRqU4IAIK+tcMnUvodEKFDrH8TSk0S5tztL2xwARskBpgsb2PBFs755zGdw/SqseqszHcTg8dKv2uoMCNjFGzwwPFCjJ7nQsHQktG0yu0eG2vmOQHo64P5U/aF5PPP3jXYadq8N9/ouqRxzdg0ihsfjTrzw5aH5oQ0Q/wBlsg/ga1eGk1eDuZSwc4OydzH0O6QSNbyRIpZfkcAA9uK37a9jtZkCfIQd24yY6D8OK5q60y4tbnytwc43KQMZ+lXoYYL+El7mTzlUBkC4ZT3rzMTQcJe/oefUiru2/U2bvxQqylYI45JTwZWGR/n8Kv31vNc+BpNSWWR54l+0GJQFHB+bIx82Bk/hXGTw28FxDDbM4O3bIWO4k569OOMce1eppsm8PzWwjV91q0ax9A2UIwRjvXTh4q66rzPKrUXE4bwhPNqumpCGLssjeY55wCc5P516bZ6dY2QzDCpdwCXkG4/r0rmfC2iR6Do8MEoUzffm2jILEY4PfHSt+S48vk5wPSuhqMJtxOaEFFa7miZARnFVpGLOcA5PWoopd6HaBnt700uBGzZIUAsdxHH+eaer1NG2ExJXYDznJqtI8VvC8000cMYGC0j7QPxrlNe+Ien6YZIbMfbLjB+YH90h/rXl+ra7qGsTNPe3ZkYdFOVVfoOlNK+xSh3O/vvHm7XbW00qNJbZW2vJJGSZCe646Dv9a6vTNcg1AiJ1MM/YMMBj7Z/lXhVncvDdQykB/LbcMEEflWnqOqzRWp+zXPkXYIkwJfl45Az7/WtKVetQqp03p1XQboQqqz3PdHk2iqEt3h8ZpsGopqGl2t6hGLmFJvlBA+ZQTjPbOaotG8kuc17WOrrkXLucdOhJO5qxS7sZNTOwxVa1jwBk1adRtrylUfU9KM+VAkgHerAlXuaogAVIi56muqniJx2YSjGZc4Peq877RipVOFxVYgyz47A17VCamrs8utS5ZaHyo17v6jFXrE+aD83HYVj44qa2ne2cEHj0rxHHTQ6l5nqXhzU1sbIJIwBHc1pRa9b31+bZXUkDJrzD+1CyAZIqC11CW1uhNETmub2N5NyInG6sj2HULO3uLflVwKoT3EEFsckKFFctZeJ57uRUc7Qo596Zqty08ZAYhfT1rKVN3SZEYtXZy2szLfarJJHwhOBSRRqsfPBqw2n4Uup5HY1TlldMqVxXYndWRoBYFsZqOUYqNWJbJpXbNO2oFm3vZo4njDEo6lSD7irP9pJBp8cG3c4zx+JrNQ9KbISZOei8CvXUU8pl/wBfI/8ApMjNpc5IHLk7jyelSrggetVMkdKnifd16jr715LRtF2LQjyPWk2kNyMD1FSR4I4OPapY13OeM1i3Y6YSIDH3UHNTRRHy8u20ehqwFKHpg+9IVy3H3uvFZuR1U5jUBbhQTip0SRyF24AHBPakT90nYknscmrKqWQZbJPZaykzthVKrIeVZyQKaIvMOVQBRV5LUH77bQeoHenmGOKL5ju5yqDt9annN/bKxlyZbJwBjgYHSqV5II5FtwcsBl/Y9hVm/ulsxjrOeVX+57n+grFBJfcSSSc5PeuqlB7s8nHYrm9yJYB5qFn3HqSAOvrU2CDzTNte9if+RbhvWp/7aeVF2kzW8LvJ/bFmYnaOVLmN0cdR8wrovHDGfxtqpyCElCDHIwqqBWN4KaCLxbphuW2QvOI2bONpbIU/gxFb/jayktvEsskgOLsCZMeuSrD8CteHU0mi5PQ5W4txJFgnk/pWWVaGQqwNbhXBxgk9iKr3FsJU9GA4NOMrbiTKcZ3GtS2l8xVjdsSD7j/0rGUtE5BGCDyDWlCjMgcEciipHQd7F6OS+n1SGzspVilkUjLcAnn29q1oLDxLayFodQtlbBBO3P8ANKwIpZBrNswcLIo4bPfnFepafDJrMUT2tvJJMygkIuceua9PMMd/Z9LDQpUab5oJtuCk780urV+g6cVNu7e5nW+meOrq3Uw+IdMljVRlSoOz2IMX/wBaqB8CeK2u/tDahpckrMXO9dwJ9wY8fpXe6bYm1VZ5Mb2JQ4OcD0rbijaTZgfdP3fX6U6Ga1WuadCkv+4cf8j1qWVwiuao39+x54/g7x5cIGbVdHwOPliVT+kVVG8AeM3IzqelnPIIz/8AG69XXEZIDD5s8elSwupYHAboBnt+FdH9p33o0/8AwXH/ACOjkqRWlSdv8T/zPF734ceMreIyF7O4THzGH5iPw2ZrmZ/DeqIx8x4MjrjI/pX1hYwKq8g7hzmsvXvCmmazlyghuj/y1jHU/wC0O/8AOlPMZ/Yo0/8AwXH/ACMaWIpOXJXlP15n+X9eh8oyaPcoCWCfh/8Aqqq9m6dV/KvZ9c8GXGlygTR5jY4WVeUb/A+xrlbvQ1Ab5fpisv7YqrejT/8ABcf8j0XllCceanOTX+JnnvkAAnbxSJ+6dXj3q6nKspwQfUHtXTXOk7F4BwT1IrPmsWRSVX9Kf9tVP+fNP/wCP+RyzytLaT+9lHUdUudTaN76V53jTapIGcf1PuapQzRb12BlOcAmrslmd4Qryec1nzwGKTJ4Oea0hnEnp7Gn/wCAR/yPNxOEnF8zbfzZdywJ5GRwatuuYYZc4LZU/hz/AFrPikDKw9ea247d5tKXZyUPmYz1GOfr/wDrp46rGvl8K7hGMudr3YqOnKnrbzZxqNpNJ9CtDwM9/SrKmMxMHRXBxweoI6EY71FbqCMfqal2qjsgHNeEFzUh8PeINRsrzVBAfsVrGzvqE3yx7R2T1PbAHX0rItLBG3SSncxHQ84reg1vUYtAu9FSdhZXBVniJyMq2ePTOBn1rCRsSkxOVDD09vSod7WO/CxdV7im2kjZQNrD7wK0ohZwcjv2q7ABLHiE/OBlizYA+n+NWI4cli5ZG7nruqG+57lKm2tTLSFlJB3EY7UoZo+xx7VuragxbiRu9O1VJ7QDoeKhm6olWIiRRtJyB3NWrckEqefUE1T8lonBBwPap4jvZSTgg84qNikuU27SVVZQDyD09K7HR9RE8Jt5XyAuRk9cdq8+MqwMrgFjj16VpWWoCKZJk5XIJzVxk1qjog1P3Wd80CzxBSvzISy/1pRboTkoCSMZxzj61HbXe4JKQcOAwOetackXyhgOorSvaUU2fM51QdOtGrHS/wChyOtwQWdzHtlVZGwwZjjA3Y6/Wtm18TyRTSQvEfLiyxdh8zYPOQOB9RWN4whi/wBDmcZMe9ypPDgY2j/vo1gWM0sMamTdJli3Ldj1/CuN0lCPNDY5KNdTkqdVX8z2SOaK4EZjLMJAGQ44YEZH6VYKs7rslB8vgru6d8Eelcr4YvkudPkWN12QONuQQcHs3vkHHqK6K/1ex0Oxa7vpVBByq4wzH0rKjtZmNWk1OyJ7q5g060kurqeOK3jwxc9O/AHc15P4o8W3WuyvbwM0FiOFiHVx6t/hVbXPFFzr0w+0ALCpzHF2X0P1rH+0QE8xAH2Y1utdy407blOSNWXAyDjAINVXXduJ+bsCBWiWhdQNsij2IqBvKzu2uQT3OMfhWqYOxQIK4KZ9sdQagu0Y27g/MWBBA5xWgXO8DIRc4+Uf57VU1RBawhomVgzbQRkcYrSL1QRu3oe66JqUereGNOvV8gNJboHWByyowGCvPORjoelWlyWBrmPh1azWvga18+AxNLLJKu48srEYbHbOOPbnvXUqpPSuqq72uUorZFlHCLzUU94qdTT2gJTNY2owSEfKSOa4qt7aGdbSNzTS6WTgVfiX5eM1g6bC4Izn8a6aBMJRRm+oqM00QSPsXAJyantIuNx6mo/K8yUegrRiQIuK9nDSfKRWSbPjVDxTiRUQang7q5yB6tVi1CvNhumKq9qVHaN9w61LBnRWpiimyMDin3t2Wjyik4rBN47YHSuh0uEXUQz+IrGa5feZLKUV8ZF27GU+9JLCrLl161qXVvHAwDAAetUWOcopBH51EZJ6oi5jTRqjfL0qDOTWvJpE8kZkB4PQVkSRtDKUbgiuiNmUtRQSDSiQNk7RSZBFNK7XZcc56V34XMcThYuFGVk9dUn+aYOCe4/epONg96abgA8J06GmOwAKg89zUYrpWd43+Zf+AQ/+RF7OJft5BMdvmFG9M9fpVsW8mcCZs1i4q3b6jcQAAkSL0w4/rUyzrH9JL/wCH/yJUYx6/qaAtpO0zZ/z71ILSXIUXL/5/Gki1eHjzLd1PfYwNWk1bT85ImB90B/rWEs8zFdV/wCAQ/8AkTaMKXX82Ni0q5YjFy4z3HT+dTjSboZC38ufQA/400+IbJBhFuGx2AC/1qvN4om27ba3SP0ZzvP+FR/beZvrH/wCH/yJdqC/4d/5l59HuUhMs2qSKg5LNnA/EtWFdX7QzbIL2ecDq+Soz7c1Wur25vmD3M7yEdieB9BVbGSa3p5xj18cov8A7ch/8iYz5X8Kt83/AJkrTh2LMgLE5JJ5NOV1Y/cFQhCelTpE2MAZJ9K0/tzG/wAy/wDAIf8AyJj7NMUy00PzUotQwClvnPYVOLGJNu4MxPvjmuPGZlWxSiq0r8t7WSW++yXY2hQfRFZZWQhkOGByp9D2r07Wb6DxPcQtCx869tori26cTEYkjP8AvFePcL615+LWHCqbdgTxuOefpWnaxLDGsQyu1v3b5xgg15lWaklYqVJxWoDBHyo2O4Pf606G3Er5yMf54roH0eXWHN5bNGd5zcRmTaI3PUj2br165HpWlYeDpJiokvrS3TjJHznn+tZe3h1ZztpHLWvgzUdeuxHpsas4GXZ22qo9WJ6V1mk/Ca982W11PUTEkQDZsbczF8+jHCiuusNIGkWHlWskskLMSZHXYWPqRWxoV99hvxFPOoSYbfLVgwVuxPpWM8Y01HoXSknK0jgIfC1h4f8Ai94f0ywspZ0kspJXjvnUmV9sw3NwQPujjHavUb03tlD9nMdhbLKrAR2yNkAdfm4Ht0rkNbfZ+0B4bIPI05h+O24rsbyVrq7L8rgFVIOenB/rXv5pFTWFv/z6X/pUj0cDC9STton+hjrFskKRkEZAwPerO9opA644GSOw9acQ0cLeYmQD8reg9fzpqupLKRgHp3zXGnY9ty5iUcEjdznOQO3XIp4JWVBvHzYIBPegEElSSCFIGBxjvUUxG+MMW2cZA4NXzWMt3Y14NTZVVSTnOOaQaozyYBJHsPzrn7iVk3qxZcfKQfeojdyLACAFBJAzzxwf50OqJYKL1XU6C41FbgNExBVjgowyD9e1chrGhKyvJZlQe8QOT74P9KsJMC7AMTjpzj8xUomJBQfKMckmpc1LRnVRoug/cPO7u12Ngx9Dj0+tZM9mfmOcD0xXpd9p8eo5JcJKvAkI6j3x1rjr/TZbacrKmDnjnIP0NYyTR6MbT9Tlnstjqzfd9+lY+o2Xmqz7ckZ5HfFdhJCWyWCnqMdhms+4th5eHBKjkgcAVHNZ3MK+GUovQ4aBSshUnkDkV6v8O9HGq6naCWMPDDGsrqRlXGAAp+px+Ga8xuowl6xHevbdH1vTfh/4CsprucNqmp24mt4IxuY5T92T6KOMn1J6816+IvPKIW/5+S/9JifHVYezrSj5fqeba1Z2ll4gv7PT5Wks4Z2SN2BBAB5U8DocjPtVMnEgCjPHHGKY00l2GnuHL3BJMrEfeY87/wATnPvURnJ++5JAwAK8syaadmXkkZDuDHeDwAO9RuDHPhFBDgMvAwCeoqqkvzb1G0ZxyM5rp9L8KX+qorSYtoGHBdcu30Woavoehl8Jyqe6tOpmRQLDcmPzImf1jO5PwPf+X1rVhUTEhjhumTxn8K6ew8J2FmrB/MuWPeQ4/QVr22l2cSsfscKgfd/djv7ev40/YTkfSwpuK1ONhg3sUAbzOcAck+v6VEYYxKhKGVSR8obBb6HFdsLOPO941YZzgIOPTtUgsxLhI1XIzt+UY96Pq8l1OjRbs8zki8tuFLoTwR1qAwuqM7I4CkAtjABr0t4nCHbHnacHAPWmmXcPlVtwPR+eP6/lR9X8ynS5tUzzbzPOQ+g61JaTDO08DPNd3PYWk7Dz7SNgR94Lgj8RzWVc+EYnJksJth/55S8jPs3b8ah0ZLRGLpThqjT026zpac52Hb+FdZYz/aLeFVG5mAAA71wlvDdWdk8M0LCdmChcZLH0GOv4V6Fp6L4bsoftAEmqSRgCPPEA9T/tVCfutSPDzuopwgutzkfHsaDWIbVXB8mBQwz/ABkkn+dcqGy4jTnbnbgdfpXR+IdLs3uVmjnf7Y0m9oh85cnvjsax7vStTtbXMFqeRzg5cD6VnVlzJQR5GHgk3Oel9jV0DUk0KC8upWyoUK6ry3IOB6HkgYrl9V1K41jUJJ5JSseT5MTnIiTsB/jVD59xDh+Ooz0NIdh6MQe4IzipjBROhyi/hRI0UmMKytzwNwpNjhyGZVHpnJphQPnBB6Y5wRTZJY4uZM8dyelXYybJCo5BmTBPBIPNDR7QcSgDHGAcmqEmp2aHgs3t1zWc+qzF28tsLnjI5FWqcmEYykdBYrFJfIY5GVTyRtHbnP6Un2K78U6tDZ2SiRWOXnePaqqOvfB47dT2qHR/C2r+Jts0ai3tiRm4lG1CCcEqB97p2r1rQ/D2meHrM21lNKWfBmkK5MjAdT83HfjtWLr0KVS1SeopzUFprI341jSOOJdoSNQihRtAAGBgdhx0q3HGO1ZiRTj5kAkXsVIz+XWrsMjKdrAqfQjFdrrQqu8HczpTsrMvCLiq1xbKw6VOJgBUT3C9DUyhcdVpojgg28gVcJZVximQSoRmpnlWrhh09WcUbx1JraMgZPWp5nEURY9hVVbpVA5rK8QausFk21vmIr1aSilZF819T5XeII3yng1G+FpvmNnmkOWrllZspIcJKfkGoduKegJIFS7DaF71v6JepHiN2wc8UmmeH5tQGVBx60upeHrnTRvGSo71jKUX7rJubt7aJeW+CxzjgiuWdpLK4MTkkdjVuz1xkg8qUfMBwaz7yY3MuVUn6VMINaMbSOq0u9guokibqBiqeu6VBIGlThgO1YloZbeUSBtuOw5q/das8ke0xqeO5PNTyOMrxZlZ30Ma0tJJ59g+6p+Y+gp184W5faQWPcdqklvZlj2KQinoqDFUWOWJJzW+7NRnehRS+5pV9DVABHFKo5yR0p5UnGOSeBV/+ypRbhsHdjJFS5IRS7ZpnU1IVKkqeopuOaAuM6GpljV1yDg0xoiw4qSNSowabAhZdpIzTQPmFLPndSJuODnFNIZaii82ULvCDuT2q7HES4AIUDjk9apJOIEKgFs9T0zUi3cchCFce5PSspRl0NoOMepoQCEQNnJmOeBxj8aYbllHmbdxAxtwKFji8ksMsB1waiaOUAnIZfbn6VhZX1NlJl1bzdjcDuA6n+lW45DckKF6D5S3IyKyVTK5PQdTitiylWJ1Toqn9Dx+PWsppLVDkrpo09M1Q6XN56qWJ4liJwrA9VI6H+leiW148sUc9pdRiB+V34jKHurADqO9eXDM7mMr+8J2gHufSu+8OxbbbEpVROoZ41J2qRwp56Njg88cVz1Yacy3PPnG6NoXMuPMmuN5PGUU4x9aJJA+GOdrg4G3jH9aZI0UCgLAZXI43M7Ae/XFR7RKS7llyOg5/wD1CvPreZENzNubz7T8ZfDc/wAuRprggdOFnFeh22YkXce3J/rXk9zIth8U/DkhDMstrsGeMb2mQH8M5r1uNxMoDD7w4NfW49tUcI3/AM+o/wDpUz18FOylF9/0QySNiFEZBU9c9DTJLdHPJwwxt49KuCMqiD068darSqRMHUljnoK4ec9CE9dCEbUfnI2jgA45qldF2bAwwYjrV2UqzcLx/dI6GqU/BbYQTycDFKVTQ6abs7srXEhmc+YTkADOTzgdcVSY/N5bHIVgRmnSzsXyVJOPxNZrvmYZbGBXHPEdjb6xGCsjSTBJPGWOAf1qyqu6nnCk4xjk1kxsd4KnP9K3LQYiUnJ4xwaKVdyZCxSk7EbBIl+YOD2wf85FUrmFbuLypVDJ23Hmrk8hU8rwDn1P5VVLne5UbsjdwK7lPQ66d9zlr7STaSbkBeNjxnjHoDVK8tYZIBHvHTlicAGuvlRZgRKRtcdD2FcrqKGxkIRVZUO5d/8AFjpx6ZrKaS2Oibc436nE+Ixa2VwtlaRq58v99PJGC7Nu6DP3ANo6YPJyT0HO3KLCqvIp5AYbT+VdT45n0i61qG40ZFjgktw0kYXbsk3NkEfTH1yD3rC1WMLa2pI4KKT+Qr7qpXWCyXCuFOLcr35op69/X9LI/P589SvJzvcpDVSOdz9McgGr4guJdpRlcseNvf3rJurQxTAwj5XOAOpBr1DwJ4baO3ivrkK5Ubo1b2PXH8q8aWcSsuWjT1/uR/yPQwWXSxNT3m1Fbu/4LzKGm+CteR0uorqwgkUZAmBYj8NhANb39mePd28a3Y7sYGFGenb93XX5RySr7CFywx19qswMqkBFJkI56cZ7D8KuOay/59U//AI/5Ht/2dTpq0JSS7czOJi0Xx9u+TWLDI55Qf8AxurUfh34iEF11zTBxnO0f/Gq7+C1fapZfkbgE9DWzbWQOCEBI5G7mtVmsv8An1T/APAI/wCRx1qcY/8ALyX/AIEzyhtB+IxjC/25pzID2Qf/ABqq8mjfEEsA+tWJZjx8g/8AjVezSae5XATBIz0rPubHCHJCn0Izmn/as/8An1T/APAI/wCRnTUG/jl/4EzyKXTPHZXzH1mxYjg/KCcd/wDlnTjonjt7bzhrOntGBjhR8o/7916JJZBEfKl2bkY45rNntGhJUkqmcAgfzNL+1J/8+qf/AIBE9CGFhLRVJ/8AgT/zOFOl+Nzgf2vYkMOCFHP/AJDoXTPG2cf2zYr2OUHA9f8AV12jDuiFWxyM557npxTGfgEgnjBB5olmkv8An1T/APAI/wCRusAn/wAvJ/8AgTOTgi8d2k6Sw61YeZGSUYxK2D0yMx0kdp4+1C4mzrNqWPLSsFGSe3CZzXTsphKs8XykZGe4pLa5+y3PmAZUjp6iuSrmtR7Uaf8A4Lj/AJGGJyWnVg3CUnLo22zBtPCvju0DG31fTFLnLMV3MfxMWaL/AEvx/YafcXs2tae0VvE0rBY1zhQScfuuvFehQzLLGro2VIyDVTxJn/hE9Y/68Zv/AEA1jQzWpOtCEqFKzaX8OPf0PlKkWm1Nu68zktONt4g8IWl5qMEUt5JG3mTKu0rh2UYx3O3J7c8CsnVfCdzDtmsUaQFRvi+8wPt6j9a1fA1y/wDwiunRbLcRp5mQyAlyZG5OfwH4V1v2yFWDFYVYchl55/E18/nNeGHzKvTp/DGckl0sm9F6EUpVVaSZ5LJoeoJbrcGwuhCSVD+U2Mj8Kgl8La/exskGnygbd4MpEYI9iepr16S9VvnaUsfXOagdhLn5+D0NeY8zn9mP3nT7Z3vY8os/hxq0pY3stvaIB8pDeaWPpgHiuq0jwZommndJAb+XIIkuACqEf3VHHX1zXWmGF0IknYHHUHGKdbwWttzAm5m/iJzWVXMa1RWbt6af8EmVWo9GxsSMVAEf7sAbVUYAFWFU4A2gehzTicj5j26CgcdP1rz27kIlRCF6H61KkkisQxBH+1yBVMsw6E59BTvMfIDA88Yx1oi5Rd4uzL5rFn7S/n7PIfYejggj/EU8pJJE8oIAX171XacwpzwemPSs661CaVCv2jKDkJXqUczrW5ZakzaZejv2Q4/Q9qdJqTlcLyazUmWePzCxMi/K2e/oaVZBmvZp4qU4JxOWbknZmgt5LtO6sm/SW6PzNkVe8wMtRbgG5rSjVmnqwg9T5wxS5xSAGgriu06Rcg09OGBqJeKnjUscCk9BM9J8I3kH2RVOA3etTxDPapp0jyFQuOtebWE09pIu1mAz0pt9qNzqExNxK2xT8qE8LXNOleVyLFWYRGZiuSueM8UCQDgCmOyAdOaYre4FajLAkJHAxUcjhevLelI0pRR3J6ZquTlsk8mmkOwjEseTnNNxyad+FJjirGNPSijvQMkgdzxQIs2rbZ1YjIXmuytbiCWyG0DOOc1yiQGC3IcYcnmo47qaEkKcCs5Q5xuJa1VYxcEpx9KorRJIztljzTd1WloSaNnGshwRVm6tPLTcBVGym8uQE9K057kPH1FKTZm7pmHKmTTVGKml6moQRmqTNQYZpqrtbNSZpG4FNsETJKQMoSDWzZQ/abbzDLh+jIDnFYlqQXANa8bNbkSRNtbHUd656qvoawbjqOuRKi5RMBux71FGqsY1VTvY4zu6Y5p93rCyoFMRVgeuc1Hp0qG4WUkNtOSvpWPLJRu0dEZps7TSdBu9ZQ3NrHmNZAkj7gNjcEH64OfwNdtbaZrn2tWlv1WBcExqqnf/ALXTjPcevTrWT8N5ppPtZhdgH+XbtBBI5HJHXg/nXoca+cvoejquevYisJaM5Jq0mjnpowC8bKSqk7QDtpkaxhQY4jjrySTU7lJLiXDZQMcFhjjtUzMDzn7xzkDg15Vk7+Rg9GeZalbSat8XbK204H7RG0bOJDgZRfMbH/AR+deqaXqazwo2eqjrXEW8S2vxt0S9aJk+2W0k2wj5iQk0Yz/vbAfxpZ9Qk0HxJeWUowqSEqM5wh5GPwIr63NHy0cJb/n0v/SpHZhdE35np32jcqnIOKUyAY24APU1y9nrUcqAqwwfQ5rTju1ZQcgj614jqK+h3RqliQqN2Bu781m3Dqoyc4zngVdaSMjJPX3qsyBwUAJB7daObm0udkavMjFunYhnUrkdq55kvLu8h3yxwWzHdLMHXKR55YBsbjjPAzXS3unsUdCm5HBGOehrKsmgtjpmmXEKrZ2l19quRCD++OPl37j83QHgjpyOadKEIy98wxHOl7poW+g39lfRrcywfZpn/cMtwHLjHHYHPtiuk8vylHy7QB24rK8N2bzXlzNHcebDGdsUsqksASSBnqDjiuimBAI43euK0UFrJKwUlLRS3MOaLliPlz1HrVFnRQygAc9z1rQvCR0PA9Bised8MACDnsD/AJ70Odj26M/d1Jm2qu4jao5JPUVyniTUB9lIVQSD16cfTvV++uZ0BJO1T+Ncdqty1xkSsze2cVHtObQ151bucpendcbic7hmtHxBbwnSNKurYloJYAhJHIkVQHH/AH0rEexFZt5jzgB0AxXQW6wnQbeyuvniOZMdwWOQR9OP1r7jOZcuSYKX9bM+R5OfFVUU/C+kvqupQxSj93GN0jDn5R/XtXr6QqscbQqFVUPynooArj/A8KW1jdlfmEkgUyYAyByB/WurICRLG+1QHy3fORXy0Hf3j7DCUFSoxivX1LKBeGByM/mK0Y1VQoAA43A465rLifhQTkk81oYaFlZxtBAI57GuiLHVXQ2bNs46Zzxz0robGVFyCQM1ysEyKo2g56k56j6VpQ3qpjBY4OR6CtUzxsTRc9jq1YPlcjHY4qheQrlum8jOCetVItTJH3wRjvTZr3zWID4HTg8VS0POhQnGRTcFHkGQUI5zWddxRFTtAB659/Wrjzo0gDdP51VnbJYhuvbHWg9SkmmZDzSJswFV1wVYLyTVGXhWLY3dcEVeuBuO4tjuMdKzp3IlyxJHSpbPXpLsQiTOAzcLxULtncjE8DC4HX2/+vT9vyGVkLR8qcHGGxxUJZXIwoDZAPP51hLU7YrsXrO/mtoguxWKP8ySkgYHXnt/9aret61FqPhLWfsb2XlCymDCJjIw+RuM9qyFCrM6uN6EkNk9fWvMNQM+lXd9ZLI6bC8RwcblwcZ9cqR+dGHp/wC1Qb7r8z5HiHDezqKtD7W/qejeBdPtJvB1hNM8pc+ZwHwB+8ate7tbaKMtCpz6lia5LwLrEb6RDp24iWEMcHuCxOf1rspIxLHWedUof2lX0+3L/wBKZ87Gb5TmzdTiYqXbHpSzXzRRkmVxx61pS6eSS2OawdahCxE5ww6VyqjD+VfcQpS7lJNduBc7ftDlfrXS6fqXmooeRj+NeYvc4kIBwQea0rPWWhYAsMU5YeDXwr7hvm6M9SSUEZRj/OlaW4YjBwPUcVzWjao1yAc8V1Fuwfk1zPC0usUSpy7k8bTbRh8/UU2S7kj/ANZwPapGfYOMVhapduMgHFc0svoyemhftZI1WuYpRkHOex61m37OqkLFuB54rnhqr20h5VweqsMg1bh1yCf93u2kDlCc/lXNPATpPmjqjSM1IZFfSW7TM5ZQQAAR15q3aX5mYHPFZ11HkCVxkO5wSc54qFLhLdsBsV6uGivZ6GNS7kdjGy7OvOKj8wFuTXOprUaLguM+mamh1ITnCmteWyI6njjxlOT0qMnNdO2jm4tiwAHHpWPJpxgb5xmu7mR1J3KCxFuRVi1wjnd17VO8KxqMd6ozMQ3y0r30Gaslwnl9eazN5DH69qiEjvxmlKt3o5bADNk5JpUJyABz6mmd6kiO05pvYAdiSSTk9OaavLVLNGAw+cZIzmmRx5PUYpLYYYyeKcsUkhwiM3PYZq8lvGiBvvH3rchuYI7ZfLZF45UcVDn2Cxy62UznG3aQcHdxir9vYxRMW3bnHc027uQ9yzJ0qLz2DcUNyYIsXeNtZxwCeameVnwO1RnHpTjorDbuRE5pMc0pIFJnNWSSo2KmEnvUMKGR8DPvViSIoucVLFYryGoM1YYBhVZuGqojRKhPWnPyKanSl71T12AI8q2RV+3keZliTlmOAKpdBVjT7hYLsOazkrlRZeudKdYywbJ71l7CpxyCOK6Z7638guXB44UdTWGY9xL45JpU5O2pbScrI9a+DTB9LvwwYvDexsGz0DJ0/wDHa9J1OT7HZTTByXxtjbGTk8Yrzz4OWzjRtVlbIja6iC8dSEOf5iuu1fUFup/s0YVoYzjeDwzjIOPXFedjaijdkVvdk7GL5uwKHEmRwPmxSvL8pkD7cDn6VI7KVK5GD23c1zusap9i13R9MRZd89xHJOQ2B5QY/Lx6kfkK8mlB1JJIxhHmdhNTml1f4t6F5LxgfYWW3KEgbFExXJ65Pf60/wCI+kXFsbbVTuZziOYk5wf4f6iqnifVLXw58SNG1k20n2SKzKkQLwXxICBnAyN6k/XPereufFbw9rPh26sX0u9aeaPaN6ptVsgg7g2eDz07V91i8px2MpYWthablFU0tNr80tPxPQVSlBTpydtf0Rz+k6oyBQGPvzXYafqJmHzHP9a8stNUsYdheW5GWG8LApwM9Qd4ycc4wPr3rXtPGNlbHBjuSAeoRRn3+9XBV4ZzR6xoSMlXh3PXLZt4HIx2rSig8z7i555J7V5Xa/EnS4cb7e9P0RP/AIqtRPi5owTYbXUcegjT/wCLqaXDubReuHkdVLF0k/iPR0to5T5cgYqRlscflWZrXhxAYntGLM3HlN1Pv9K5GP4w6Gq/NZ6lkdCI4/8A4urEnxo0J8D7HqeBnH7uPP8A6HXa+HcwnG0qDOh4yipXU0dhpFqiWaslxNsxiSAnADdSPzqe9kyQOxx0Gc158fi9oKqzR2F/5jYBLRpjA9cPzVSf4saZcZDQ36qeoSFB+u/Nc9bIs1irRw8n6L/gkVMwoRldO52M6zMDuGBzxvBxj1z/AJFZNxZysPNinE2OGLEoAPqeDXMn4kaNk7bS9x7xp/8AFVHL8RNJkHEF8D/1zT/4uvPeQZ7L/mGkYf2tNbWLGrQ3UPmRkNGcdSucZ7+9cndoSHZsgdu1bcvjnR54BC8F6Ao+RhEmQf8Avrp+Nczfa5b3KERwyKT/AHgOf1rqocOZv9rDyR6eGzPDShzTlZmRdY87jpirH2md44UzjaAAy9cDoPyqizs7szY68fStWxtmlkhj2fM3A45zX1XEFKWHyfCUqqtJX0+Ry5ZGOJxtSS1R6H4Ts/K0KIyjYkszNvIyMDjj/PWtdpMKMnjPJ61NDAsWnRwoyqkSbVReAAMc49zz9SaqXTs6qCAuzjgdfc18dH3VZn2FPV2LUZUQBlclieVA4/OruGjbazAng9c/SscOqNgOGUDP/wCurqS5UMepHNbQkTUpvc04pGWMO/3CSFJHHHWrcc6Aru3AEEkg/lWMxkChm+4eh7EipYJCWAJ4/lWqkcs6N1c2BdtgEn60rTtw27IPOKoeYgHyNu7H5Twf8ilgkLMF4UjPJquY53SW5eWU+UzDaMjk55FJ9oVUDfxemM1nrKrHBbn0pGmDqST8mOop8xXsdSK4KsvDAOW5HQD8aoTOCTnGU4wKkmkPOQMkYFUXbaDk89veolI9ClTHXDhJSsbbh24xmo0JIM2V2rhTu7k8YHv3/CoZJNxx0xnt1pY1ZZwzZwHxgH0HNYuR1KFoj3m/usCqsxHFcF4zRE1tpI23edArMT3PKn9AK7Ca5YpIWPLNuYkd8/8A164rxLMbi4V9xJVGU89gRj+db4V3xEPVfmeJxFBfU7vox/gjzW8R2UUT7RIxVwejLgkivY2t2jXpXinhe5Fpremz7tu2dcn2JxX0DNCpyBWeeNxzKt/il/6Uz4eEU4mC7bMgiub1+NbiJk6E9D6V2c1pznFZd5pyyqQy1xKZm4tHjc2k3X2hgo3c9RWjYeG55XUyk49K7yPSFSQjbxWjb6cqc7cCiWIb0Rp01M3SNIFsq4FdAqeUnFIqrEMVWlucMQDWSbvqZtIWW5IBNYF/K0oYHPPatQI0hPPFQyWJfg0X1FZnHT2c8rEJmqTaXfQzLLGzBlOQRXoltpad1q+2mR7PuitYzZauefS6xcTWQhuVVXV8hsYzgc1zl/qUquSDXour6JC6kbeOce1cBqmizxSHCllPtV0FCPuoLpvUy4b52lyzHr6112iz71GK52x8PXc8ozGVT3rs9N0qS1jC7MVpVaJm10M7Yba12OeRXL6neIHKnrntV/xHqas+yEkY71yU0jSNknNVCN9WaRuzQMwmxxwKheIOwA70tvGxUYFSw28k1yIlHJqtmWWrfSkK/d6dTVG8iETMvoa6xY2t7JRwWA5NczfoJJjj8azhNykSjMVux/OpNuKRo9pIpc5T3FbsoVcO4B6DgVZ2qF6VQViDkVP5zkYpNBYf9pZPlB4qMzZ5J5qNhTNhppIEXYRvHTJ9KeY8OARg1Z0uEKhLH5yKS+IDgZ+bNRfWxajpcVo0EeMCs6ZwGIFXMsY+tUZUOaFuSyEtk05OTTCpzT1GK0EaNkyoc06+fcMAVSR2QjBqzuEi81LWtylqioGOMU0oSaslBn2oGBTuTsRIuBUm3ikYilDjHNaws0JkbZqEnBqd2Haqx5apkhosRSMTg9K1LZTKVRFZmY4CqMkk9ABWOjbauQXG3GDzWU02tC4ysz1seIl8HeEYtC04/wDE2B8y8l4xbu/JUerAAL7VQ8M35nszaySFsSDADckE7uD9c+nWuLlR4dMguHBUTMdmf4gOp/PitvQdGvrqM3DpJb25QMkhGCxzkFR+B5rgqU7xeupFR3dz0RpYoleQ/Mf7ueT9DXLGwY6vFqDlpJVlWTJOehzj6VqNchRsJJOepq1bReYy4wcmuejS9kvMxR1+hwMLIQ+Sxlc5Y7sdec59gf5VQ17SIr4Sci3u0OPMB4Yjs3+NdLpJjuneU4DH5Ex0AXjP4nJ/KsnxRGkOopsJBmUM20Y284Ofyrmr03CKmj0cW1LVHi99JNbX0kE0BjmiYoUIHHfqOv8AXNXNJuJrWXzVWZoHGyQKMB16Eenc/Tiuu1fSIb3bcxweddwfdwcMwJ6Z6Z9B/wDrqlYiGZIo4oURZjiPz5Fh3YyMbWIPUY4B59eabxClDRepyRvL4R9vJ5Miqrl42UMjkY3Kehxk4PUY9RW9aSlyqqMnrgCmW+j2MRX7Spml2Y/dOdvUkkYI9cZPpxUU80MUzxW7HaTgoh4UDkAn19+tcdStG9ludLrciu9zXN+LUDaUdz75A/KqE1xLcMWlmOM+uQPasC91K1QljeQBoyCyrKpPBGe+az5/GGnW8PyH7W7DBERAC8Z6modKtWS3OWdedR6s6YyDJxI+T2VjVWXUJoucF09uCP6Gsiw1231FXWJnR0CnEgC5yO2D61aldsD5Dz0Hc0vYckrSRnzdC1HqsNySqNllYB1Iwy+mR0xkHnmpDcuzHy0DOTgk9B/WsWcMkiyREjHySEEZKng/jnBA46VftQZI0Kqqx4BHtx/nmqlTildFXuycruBDMTk9R8uK8/8AiXb+S9g6RlHnVxKw/j27cZ98Hr6Yr0AXcFsxaeeGLOdpmlVMgdSCTXA+JdZ8M6hPPNe3Fzql2kDw28dnGUggJBw25sFzk5zgDjpxXdltOo6ynb3UbU5uD0OP0KFpbqKBR8zy7R9TXpFjYQDxjeRY3JbErGR6pgf0rg/CJVddsDLyv2hc12uh3YbxVOZPvTySDPuc19dnn/MN/wBe4/8ApUj6TIHaE/8AF+iO0JJZTnlRtyewqGVMx4XlDjgcVIZPIdkVAx2bXLHIznqv6U0TMm/HIZdpzyK8jc+iV90VwAsh+XOehBxUoZEJKng9RjpTXIQNt+ZieDu6jpSB96dAGXIOepFClY0epb3NKFWNAEPKj1IHNJHIu7OcgdD7VUXCDG7OelO875iBwuatTI9n0RfSQELtGAenPv3oWXYcBgCc9un0qmsgCYGM8EmkkldBuLZHcmq9oR7K7sXhIHnUIMgj1zk96jMyeYVYEnHBB9u/tVcn7pLocADj0pzTbUZWCnJBBAodQXswuGAiBWQ464bt6/rVQqS4d5AoTkH1xSyT+VGZA6hgT6lvrVSeUBn2ksMd+n/66zdQ6acGtBu/dIzbcheM479qi+04i2qQXckf7o7kelVpLgLnDED0GP8APSqb3nlbsuc9COv1P1rPmbNpzjEfe3RCE5zxwRyMf41ympyfaWads5bcevFXry9Z5XRTwc5HbPrW3D4etb3wZcahKlxDcJDLNHIMbJAATjHboR2rrwc1CvTcv5l+Z8lxDiuelyrucVbFkWORTyDkexzX0dp9wLnT7acHIkiVs+uRXgVtoepHR4NRS1kltZN2Hj+bGCQcgcjoa9s8NTZ8KaYzEE+QvIOa6c5UZY+s1/PL82fIwlobJHfGapXEeckCrEcm84HepJE+TmvLcVsikYrIC2aa0m36VamQKeB1rPuVbaeeawVk9SmrohupTjg1lb3abqSKlxI05Qk8mtfTdNV2JxkiquJRuQ20bqgJU4qxsDHpXQRacu3aRzVOaxKlhjoamw5RaRnopTtWnBbGVASOfSqgQq4BHeujsY12g4q07EwjdnPX+lnZkisGTT4mbDKDXoWoxr5AwOa4bVJTFckIvA600r6oqcEhtvYRKR8gq8bKMJnA/KqMN0QgIBJq8tzmPmrscr3sfP8AqjCSQmqEUe5sGrOfOclqTAjYEV2LRWOtaHZaVpUI0xHZQWYZJqjIsVhfk8fMPyrQ0m7aSzjjx2qjq1gzSmQk5xXHzWm1ITI7/UlFuUjOWNc/I7de9StE6udx/GkMYYVvFKOwyi0hJpu8qSVOMjBqeW3xVVxtOK2VmNAvzNiraQq2BzmqiEA5q5HMgK460SGTjT2ZN2KrtH5bYI5rbhu0MGD1rHuX8y649axhKTbTHJK2hftNPup4fMjGB2J71QuYZoJz5o+b1rt9HML2aKSAcdKqazpLTEsidO9ZRr+/ZmnLHlumciJsDFMZgx5q1JZMrEEciqdzEyc4xXSrPYysxu3ccAZo2EHGMVPpRSW48turHAzW7PpcYiyB260SlyuzE9Dn/KOM0seQanf90Sp61XLYNUxJj2YDrTQ4PFQyOTUak560raDLXBNIQaiMnFSI+aWqCwhQkVGUwatHGKibBNNNgQ7T6VraLpf2u5jkljMkAb5kDlCw9MjpRbRRiIEgHIroNCuraIorEKQSDUTk7OwrnWpawSzQXMtpEvkKqwRjlYgOmK0LnUUS2Zmaud1TWo7a1xHICx6Yrlo9UuL64fMh2jt2rkhS006EtHSNqXmXiruAGa6qyuCiApzJj5R79v1xXlt3K0MiNnv1roNO1kPAsbyYPTOaqVPS6CMdUe06Vut2tY9/yxptyBk/d55+uTR42ZI4LRwdzncoRR94dyT2x6e9chf+IhbakbdjId0JlUqNyouDuJA/unOeacdbfUoIJmJkkkj2yADkZ4yo9M9utediZuMeW253VV7th9lKzIWEhGFPyupO3n1zWF4q8Q3elRxSWum29xDGrLI11B5ih2JIKnPcg5A457GuoFkn2Uo7EY4YKMk+2c/WsTU9KtruFrW5kigt2XJLEAIF/iA9jiuajOKnrscSk4O5xOteLNXubyaGHUZI7UbSiwKsa9AcfKOcE4/CsaLVdUWN4TqF15bEnaJmx78Zp8iHyRAkcRw5YyqmGbPcn09B/WmC3O09QMYBHUV7EaVOKsopD5ilJG7FSGcMp3Z3HjFSkzSfM0jc854OP0qf7OdoyPvcnjt2qWO2Yg9atyQ79CFXuNwO8Fsj7yKf6VoWuu6jZQmOPyCGO4hocnP51EkHBNSJbKwBbsOcc1nKMZKzQWLg8TXjqqGxt2AILMm9SQDk9+OlOufGVxFYGC0sI4WxtDM5bHv9frVRLUcL+ZHf6Uj2IePpnFZ+wo31iVGKMLUL7UdTCvNIZHVcZI5Ao0jxNqegK0Me2S1ckvDIvBzwSD1FdZpmiJc2S5OSCd3HfPeszV/DZORGjHjIIHFdUKsF7rWh3vCOcE0cpZTNbbJuhSVTx2GRXeaKGXX45gCCGMg+vUVws0D20ckUo5B/MV3Hhydb/S47lB88P7qQA9wOD+Iwa9bPXanhZrb2a/8ASpHVk9X2dScH3/yO2Rht+YNkrnGe9PhkVMkAhu2VyP1rLh1JZAI2Yb0BAwOoq9HNFMC2zCkZC56H1rxYyufWwqRmiWRgYSFTAJALY5FRGQAEu21yP72cGnBiAHGCMYZT3FQloznDH5ugPX6UNmnMkhhl+XLpkZ4PTaf8KaZCS2CAyjkVFO5A2/xY5z2rKub1LdS4kG5RhlzzU3ZlLFxhubUd4ChYgZGe3GO9Ry6mpUxySAh+c49OlcnLqsrOyiTYpBABGajSSR9rMSc9yc4pNuxwVszgtjpZNYVE/dtnGcH0pq64r4GG5UZB5rIWLK8/jik2quc/hWfMzhlm8mzVfVY+m1iTx7CoH1BVlKsMnbwPX3rOPzHjPHqaglRixJ496pN9So5tJ9SZ9QLbvmOQML9f8iqEty7YVR2wccVHIONuDj3PT2qMIOQeK2SKljJTV7jS2RwuT7969b1GzGneBbi0xgw6a6N/veWc/qTXn3hfT/7U8R2sci5hibzpeP4V5x+JwPxr0DxVeA6HqKk8tbSfqprrwiviaa81+Z89mlXmaicPo63Nt4as5Y5SEl3shBIKMrsCoI9Rz+FXYfEF/Bax29vcmKJCSAoHJJySfxqrosct14TtrfaTGd/Pod7ciucuftFvdSWsrsGQkEHvXTmrSx+Ij/fl/wClM8qMW9T0fw14pvLrWI7OaVJY2ViWIAIwM8EV28t6Cg5FeQ+GXFk/2hlwzLhD/M120N68yjBzXkttFbOyNuS5DE1XmPmLxUC5IBNWYIy7Bexrmd27m19Cjb2jyT554rotOgMLZx1q5bacqxg7eatSQCJQRxmru2XGNtxYZPnOae0PmE4HHeoCpAB960LcgIKakVa5kTWmCcjkVesiY1GannjDHOPrUaxMBwOKpu5CjYmuR5sZAHauYurAeYdy9etdQsi7dp696o6iqeQzDGRTXYU1pc5hrONAQKqTKV+UGrkk685IxVZnDn2pXZyySPBJbaW3Y7xjnsc1XdiTn0ra1Vt64Qbs9xzWdBYmZdzEgeld0ZaXZ0nQeGbpT8rEZWuh1B4ZIDwCcVwAMmnSiSNiBV2HXJpcozZyOKxqUeZ8yKumrDL5ljdj2rPFxknHSrV6xdDuBBqiiKTjNbQirakJD5JwwwetU3Bdvarot/MO3NWF0w7MjB+tWnGKHsY+1lNPUkGtF7YL8pHNVJYtpo5kwuSI7FcZNPii/eAmq8b44q1HKKTA77wxaxvGHfB9BW3qiRR27MSOlcRourPbKE7CtC81V7rAOdteXUpy9pc0TsjOnhDzMwHU1l6nbBY84rfVoyM1k6vMrKQK6aUnzJFdDlY5DDcqynBVs5roRrDyR4Yk1zzxEsTQrOvAJxXoOKluQ43NC4n82XPeoXNQoTTyc0uWwcjQm3JpduKcvAprNzSJYjISKap2mpTytVmzmhajLYlBFRM5zUAJz1qdBuotYEiaO7eNdvUUglklcFSR9DUbRnFS25CHmiwOLROIp5CF3MxPYmug0vS3jtxn7x61n2M0aSgkjNdZavH9n3Bu3asZtmbOW1fMLeWw5JqrbXCxurFQ4BBKn+IdxV3WB58jPn2FY67gcY/Kmtho9N8JXF5qd3qTSKi2Dw/ZpC0IzM7EsFVs8AAhz+Hsav6HKwgms3mYSwSN8inBJHXHvkfrUfgWzl0zw4091I+L3M8MMjALGoGPMxn+IAdR0Ge4qvcznR/Fis1u6x3BEnzNnKsPmP1DCvBxLU604R6L8UdEp3lc7HSr5L6MRSqY5kyMONu/jPHrx1qLxJ4fGrWMckKgzw5KJgfOCRkZ9c8iqmp2FwUmubOYpNCd8MiqDtYdj7Y3DHfdS6Z40jEIj1hDbyxjO6KJipGOcjkqc59q5qKv79MynCzOFm090kbchRhkFWBBpgsgSH2gnrgjuK9XvotB1i3W4ub2BEKjyrnz1QgEDrnt7EcVDP4c8LaVCk+paj5HBkAnuFUsv+6BuP4cmvUhUnKOiMOVnnVro17qCutrZzXHlDJ8tc455/GsySFkdhwuCR8xwciu9uPidp1lbtDpWksEjYrAZSFjI7Myjn8M/U1yuo6omu239pvCkV6pC3Xljasmc7XA7HIII+lOCqRl72xrFW3MtUJB3HIHZRj8z+FWFTK7cfKOw6UyLa3U8nHHtUxO0DPTH5/5/pWwNiooKDOAAueaemBGcjvkinadY3mtXy2GnQia5cE7chQAoySSeAK6Gbwm+jrANRlSW6PzyRI2Uj7gZH3j69vT1qZuyuzajTlN2RHo1lIsbbxjzWyBntgV1i+DZ7iFWcxIrqMZOTz04Fc9DeBpdw4UHqP6V3Ph3WBNA0DDlR8p7mklGTtI96MZ06a5Oh5J4r8FSHx/YaDAytNdWZkxjABHmHH5JXNaM8vhLxLLZ6ihit5T5NwGH3CD8rfgf0Jr07xDcGP416FK0m0rp7hnJz2nrlfiZBaXOtyz2sqyqwGX9Wxz/KvbzhqMMLD7LpL/ANKlqcWHpzk51UtVL9EN1W2a2nLocEc8VBb6yYDhyeO471maJq/nwJpl62XQYt5CfvDsh9x2/KnXkBjYkZ+teEk4PlZ6axLceeDOlh1eKf7smGGeabLeIrZkYKQvBHQ/jXGs7ISVO1vUCnG8uFj/ANYWxjGT0rdK4LMmtGdJd3WxR+9JABwOox/UVzt1KWlypXBORg+tRfaXfaTuLf7R4pvlPLJkBs4xnrmrSSOPEYr2g5FMnPGR19/wq5AjICSMDrk0yCFkbDg9ecj+tWr5mW3ZE4YjHHaoersjzp36GXea+UlEEHzN3J4FNtNW+0Nhmwe461hS2rLOqqWaXdzxxVqwjMiqIwsb/wASLwR9c810OlBR0OdtnVJICP8A61DlnHXt19aowRXLcPIfrir0cDggb81yNJFwkyu6hioAxuPJpvkM67yDwep4rQ+yMck8nNdJ4Z8OvfzreXSt9liPyhukjD29BTUux2RqckeZl3wnoj2FiZnQrPcYJz1Vew/rV7xFpzHQNSlb+C0lP/jhrqLe3A7VB4liC+EtZOP+XGf/ANFtXZhF+/hbuvzPKnUc5OUjlvAWnpP4J0+Qry3mf+jGpmu+GrF9Xtp7iHKToYWPTDA5XJ9+RWt8OMf8K/0z/tr/AOjXrbu0SdGjdQynqKjOOaOZ4h9Oef8A6UxwcXFHMLoka4XywFHAAHSr9vpixAYHFaY2kjPWnO6rXA6nMrGnLF6lb7MCMYqaCEJKvHQ0scoZsVajXODRGLJlY1opR5Yqpd3X7xVHNOjDYxTJLbcd3etVC2oua+g2SbKAZqWO9CgCq00JVTyazt0iSHd07VjZ3NOax0aXSuwHrV8bdgxiuXWVsBs4q/BqB2YbtV2BSJ724WH5qwtR1YeS3Pbip9UlMsZIridQumyVBrVQvqYVKltBZb5TJy3Sp0vAUyOa5WSbFxknircd7uXGcChwOcgTSIvJ+dQayLq3t7ZWBAUA8V0X2hQhUN+FcxrLM7N0x6UQu3ZmsU7nM6tOjPtj6VWsCBOMnr3pLkEuc1GikYIrvSsrGyOguVTyDux04rDdtrkCh7p8bS2armTJzUxi0Mv2wmdsqCRV57too9pG0+4pdFdZBsyA1XdUs1+zk559DUSa5rMzvqYr3W/vzVaWTdUBJRiPSmlia1UUXYkzSByrcU1cmnBMmnYZo2l6E61cfUMjg1kCI4pVikLAVk6cW7iuaH9oP0BqJ3ac8mmiHA5FOjOGxRZLYcWNNtkdKpywFT0rcRA61XuIcUKr0OmCTRkhMClAxVoxgmmNFg1amKpdIgIo2GtK3hUYBUHNJfRJCquOM9qrc50UCOKjYc+1S5FKIi1K9gS1KpwXwKuW0WaYLN2fCgk1rWdhOoBMZ/KpnNJFrR6ldoAB0pkdm0jHArYeybbypH4VPZRIqhTjrWHtjq91x1MJ7WS2YMQcVchvWRCu7APWtbUYBJb7VXJ9q5+W0lT7ykCrjPmWpwtq5LNcJIcbq6zwf4Jk17/S7vzrfTApYTIo3THI4TPUdctgjjHJqPwTpXhneNQ17VYIpo5P3dpLC7Lx0ZvlKtz2zgdTnpXqkOtaLqRUWuq2UjL8uFlCjtwBxx1rgx2IqU4WpL59v6+4qKXUY+lxkQwWwYx26CKJCC5IUYAJOScf544rJ8W+F7ybT4L5vlW3co46MFJ4OB05zn613Fv5aQ7IPL2MAQUACkkdz3zkUX5jn0yS3dcwsuDk8kMOen4c14VOUoy5r3aLdjh/DXiSytYoNP1KDzooj5azleQB/eUfeGO/X610s7eGPErm13WN068pEQEkXI6gcNXkV2ZLS/uY2LiVMoRIMZycE/l/OsuadkwQ+GzuUqeR3z7V6E8J7XWMrN9iFN7M9KvvhlayiSbT70xgEAJPHv56nDDH8q4TV/C+q6LOzXVowhA+WdPmRucD5u344q7L4216bTUtTqUsYRdpkjAR2PclsZJrD/tC8njlWW5nlSVhuLSkg9eSD71rh6eIhpOSa/r0E7PYrSkR5HRcdqkt5mjTCjIZNp47delV53KjqD9B1p2fLVYyFYADINdttBFq3uHV3G7I6g+v+PXNOe5DNkNhc9etVf8ApoG7HAAqJEZ5FGev601qFkzpPC2rSaT4osLy28sSLJtIkYhGVgQckAnkH88Vva1rr3108vm7nck5FcMkqQ3QKj51/i9CetaVtKDJkDA6k1nUhdo9LB2jqzWt53ZwCR/sgHiun8O6kkF2jncU37SBxmuG+0yPxs2DPU961tNn2zRs54yDgU3orn0dFRmrMteNtSXR/iNpWrX0E0lqLJkOxfvE+apAyQMjeO/Qj1ridY1y0v5swLOEUnBdQCfrgmva5ZftbIFG0FdwJ9PWuT8U6N9uL3VqWkEaj5cfw9z/ADNe7UzLBVKVNYig5ShHlup20u3tyvucUMHWgp8lRJPW3Lf8bnkskkbknDVq2+uKbfy7tXkYcB1AyR78/rSsqod45Penm33TKR3NS8ZlclZ4aX/gz/7U8KTrUpO0vw/4JVk1C1ZshJcehA/xpgv4c/dk/If41p3dz/Z0KGRDIhbaQDggY7VLby294pe3kD4HK9CPqKPreWJX+qyt/wBfP/tTJucvtfh/wTIN/bk52SfkP8acupQBwdkmPoP8a3BCR2NSiEA9OaX17K/+gaX/AIM/+1IftF9r8DITW7VeqTH8B/jSTazaSoFCTAd/lH+NbyRAHP8ASpQoxUfX8rX/ADCy/wDBn/2hPNUX2vwOPa7syS22Ut67R/jT1vrQMGMb7h0O0Z/nXVFQzdM0q2xL8Kee9V/aGV/9A0v/AAZ/9qCU31/A52PWLRByk3/fI/xqyniCxVceXcf98r/jXT2umvM3C5rqNL0m3hcSSqJHHQEfKP8AGspY/Kn/AMwsv/Bn/wBoO019r8Dz2z8S6IJ1N5BemIclYkXLe3LV10XxU8OwxrGljqCoowqrFGAB/wB912yt8vNOSXBNR9fypf8AMLL/AMGf/aCcpy0cvwOMHxb0EdLTUv8Av2n/AMXVbV/ipouoaFqFjHa6gJbm2khQtGm0FlIGfn6c129xcBRmqy32e9deHzPLIyUo4Z3Wv8T/AO1MJxa6mT4Ela18C6ZFKrIxWRgGGDgyMQfoQQfxrbW6DP1rG1W92xlwcHNV9MunmOT615+PxH1qtOta3M2/vdyYpo6MuM5quSWY04AlOtIpCda8yNN82ptzaEkKbWrUgA4rI+0qM89Ku2U5duua7oxSRm56mwgAxSuynvUYc7aYGG7B60adSk30HunmA1nXUJHStRFXIINNnh79jWc5RRrFNmdCqNGAw5qKT92SPU8YpzYin2E8UyZstxUNoaWhFKPMjI3dq5HUbRlLA/nXRXU4hlCk9RXL6xq8JmYI4IUYJz3rWm2znrLqcnfOYZiD2NZ02sGEHb2pdZvBNMdprBmDN1rqjBdQgrrU3bLWDNxmpLwtKmcVz2jndOEPrXaJZpJCMfpWVRKEi3ocbcW+WJxVZ4ttdHqVkYsnHArnpyA5rSMroadymUJkC1qW2nQvHl+tZ/Vs1dgvCi4KZqne2g2KiCwug6k7e9Xp7tZI8+burIuJzITximxDPek431YWI5hmQntUWKtSAY4qvitExocgA61MCAc1EAaMkUMC0jLuGelXMjgjpWUWp6ytjGahoRbmnAbApkWWbiqrE1b08jzOaHogNe3iYJkiq95wCa2LdQ0ePas29RWyK54q71LjVsZKuM0SSDsKjYbWIppBNb8quVKo3oWI73ylwUDY71Vurtrhsn8qVbaeVsRoT9KsR6DeyEHyzWl0t2RdIqRDcRWlbwMcDaea19O0IWq7pxuf09K6Ox06B2B2iuarVXQI1IxZR0PRQ3zyKMntXXW+jRbBlB+VS2dmsSjAFaEbbWxXBNuQpVFJmDqelIITtTnHYVwUcdw+rNbxAgA88V7BNCJY+R1rDOlQQ3LSbACT1xTpT5UyZVGtEU7HRAYgXXccck1T1bRY1jY7cEeldUk8cCDJArD1vUYxE2GHI4ohKTZjqcjDGigrjnoas2ghjuE3YxnvWFNdOt0xQ8E08STSkYJ6128l9yrHfJK0JR7eRo3U5UqcYNbdj4rvYXVbi3imjB5ZBsYj9Qeee1cdpcksqqrdq6e1tlC5IrhrUoSXLNXBSa2MTxTpzzamb6ESTQXfzhnTAL9GXHbGP89a5G6hkVgCQTkqpPB465r1drC3uYwkqblzngkc/UVlXfhNpjuSaGX5s4lTaRnryM0qcuRJdEUpI8/WTJSNsEsM0saKYhs3YHJ+XGa3rvQLiJAZbSRFBGCyEdfp71BHpzBnhZHVscjaQcHoa05otaF3MUWrhkcjjOenapTauxc9MDjiujs9Gkudgb91Ht++4zx2465rY1HwxY3mhSWMH7ufh0mY5O8DHP8AsnuPfNDqK+oro84kmihOco5H3RGf5+lQtqUzxiMBY/VlHJqrc281pcyQTxmOWI7XRhyDUWfmx+ddigjaMUiyZzkAcsx5NaEFy6xbS2ec4XpWRH8rbmI3evpUgkJIUE49u9JxTO2izoftIMe9lJx0571b06Sa7uFSME5wMCsGG4YFCSc/dwRWtpt8I7mNt+35hnHHfrWM42R7WFq2dj1W0WK3tozk+YowSeOlRS3YJ84IoQnao9eOaw21MTrhGYxlgpJ7VVm1gNHkPhUBUYP4msZa6HZNx15mcVrISLVpYlBwJTgfyq7aoJERscDpWfcSC91R5wOGPH4VsWq/MemfQe1XLSKPmsZbndjK8T4W2hTPLPn8h/8AXrl2DxOs0TlWXupwRW34iufNvhEDkQrtP1PJ/pWGd3SuugrQR53U27XxBcxRfvUWcL1JO1sfWtAa9ZzwnBkjk7K4wM/73SuXhcduncYp0kWz54xlPr0+tEqMH0FzM7mymhePBurV2z/yzk7e+a1EtJJB8sbMT6Ka8zhEc0scbuEViFLkZ25717hpd0IY40Dk7VC5J64GM1yVqXLqmHPqY0Wi3RG77M4XuzLt/nU6WRRsFcn2rqQxucAnipF05XfpWEYNvUbn2Maxt2De3pWxDCVIOKuJYKmMCrBiULWkoMlyKgOM5qNmwSc0+YgZqjNNtQ5NYuGpPMQX9xtjbmsODUfmILUuq3ZELYNcv9sZXxXXSppIhu7OhvbkTDGa1dFRSAa42K6aR/mPFdVpE4AAzgdjVtWGkdeI08vis273KDtFSpdKE+9UbyrJkA8UkynHsZDTTNIQAcVt6O5Y89KpPEAcgYq7pbLvODjmplUGqWp0oQiPIrJvb5IfnZguD3rU88CHnsK4TxVcFwIo+rNnioT5jVrlR0sGsRyuuxwRnnBraEyyRjBrznQrd85fPPSuyhlMUYB5puKaEpMj1Da0iuOCDT1ZDHz6VVvJAQcHg1n/ANprCNrnBqVG4uez1IPEdgbu2PlyMrDupwa87v8ASLy3BwxYD1r0aW+SSM/MDmse+liZD0rootrQ5qkveujy6W0n8wlgc1WlidCdwrtJ44XLMMcGsq/t0eJgAM44NdSlrYIyZyCObO73A8Z7V2+jalHNCvzgn0rhrr5pDjpU2l3j2twuASM9KmpT54+Zsz0W9s1uoSQMkiuI1LTZopiAjH8K7TTNREkQ3KfqRV944Jjl1Bx6iuSM5U3ZmadtjzBrGZE3MpFRKSG2mu81mCARM2FArg5CDcNt6ZrppT51cuLuEwyBjrSRDFSbcjmmNxWpQSN2qEinHJNJinsMAcUHmgU7pQIZsJpQpFOVhnFSqAxx60NMCJQWOKuQxuhDBT+Va+kaILiRWccGu5tPDNuIAdgzisJ1UnYVzgob10xmormYMSwPWux1fw1HHGXjADCuLuojG5QjkU4tPYlbmdJ94mnW6h5VU9CaWQUxMq4I7VZZ6FolhB5SEouT7V0y2EKR52ivP9N1/wCzRqGB4roIvEP2iE4JFcVSnO5k0yv4gnSyiZh0rG0nxMPPVHG0Z7mq3iK7kvH2rkqOtc7tKnuDXRTprl94ajdanuGl3a3EQIORitIJk5FcJ4Qvz9hRWbJrthOvlA55rkqRtKxGzLLy7I8+lc9quo7eF61oz3GUx61zt/GXY8ZpRhbcbepmXmrTkHBOelc7d3dxMx3MTWrd7Y2INZp2MT0rrgkkMr21s8p6ZrobXTdkKlh0pNIt4j83Fbk7IluSDjAqZyd7CcmyCwZYn28Ak8V0sUyIgzivNpNW26jGqN1YA12lvcrJCBnPvUTot6gkzZW9VWAyKtpdBgOa4XU72S1ukKE7SOlaumXzTRqzE1jKi4htudVv3DIOPpVC8jyp60+KQhetOkIdetYuLTKTuYhLRSd8VpWrbwM1DNbknOKsWaFSKt7FpIy/E3haPW7fzoisV9GuI5D0cf3W9vQ9vpXlNzaTWkzwXEbRzRttdGGCDXvrAbK5TxR4dj1pFkjZYryMfI5HDj+63t6Ht9K1o1XH3XsUp8rs9jynB2FiePemxPk5wcDnrV65spIJ2guYmjlQ4ZG6g1F5OwfKMZ4zXXzI7ITBCQdxbnqB6VYjDlxh8Z5JJ6AU2GIFWcEDHVjUjghCACA3A9//AK1Q2dUKzWxebWZZ4o7ZG/cx98ctTJZndgmRlj+QqG2tyFI2bnY8A8f5FaEFhhfmwXJz061k+VFyrsZawhZhsHyqPmY+9W5LhbC3mu3AJ+7Evqf8/wAqnt7KRiYolbdgszAchR1P5Vy2pX7Xs4KrthQbY09B6n3pRjzvyOGvNL1KMjtI7O7EsxyT6k1E2AD6ninsOcio5eAPzrsRyEkSjIzgGrccMmd0ZyPQGqcT7fp61Plh0b8cUO4Ed0nlsGC7cnDD3r13SIZn0q0nlMZkeMEmJtyn3Bry2PbPhZRnHOTXrPhCIp4ag3FjudmUMuNoz29u/wCNY1WrJMzmbWnMf4uxrftmTbzisq2gXBI71aYiFRg1MIoyuy7LcIgJzWa+op5jJmqd7ebImrkLjWvL1Ax5PIpyV1oaNPc7KW4DkkGs26uBtIzVG3vGZN3JrOnuLiaYqqNWEYq5Mtg1HEkRGawmt+eK1LlLhI8yRsF9arwfvDkdK3toJaGfgwuCeBW5pl+mwAsNwqneWrtGSFwKwBJLDcYUleaajzI0VzvzqQVCS34VXGubHK9j0xWJCktxGDzTWtZY3yM5zURST1LV1udYmpNJH8xH0FWLG6McvzHg9MVz8RYoG9u1W7aXdMqZyc54pOKZblodmLvcnfFYl1am4uvMYd+BWnaLmMZqVoQCTisZaLQbd0R2tsqRrtGCKuEkJzwDSQL7VdihEq4I6dqimnuF1sY90jeXuzwOtYtzAbn7o6V1lzCqRsrDqMCspYQkmAOKJT5SZRuYB0yV4yuSOO1Zl1pNz5LKCc9M5rv0hU4wKivbVfLLYrWlWZDpx6niWozXWjXAimBMb8hjVZtS+0KewIrp/G1ss1myBM4OVOOhrzy2Y5CnOR2r0IWlG4nFDnUMela2i2KSy8gZqkYMj5RS2+oSafLleR3qXdqyGz0KKwhht/l4OKwNR1SWxJGeOlU18Uu8ZBbnHSsS+v5LtyzdKwhSlf3jNQ1H32rzXYIJwKz4yM5NMJzSZxXUopKyNkrFkyACmfeqDfk0u/FVYdiwEyKCtRCcUpkz0pWYrDtooxxUe85waXf2osITbk4q1ANrAmqynmpvMCiquDOx0PUIlAVu3eu4tNVjEYG5cY7141aXnlTZBNdCuqbogQ2Dj1rlq09bmbTT0Oz1nVo/LK7hzXnuo3CyzsVqpf6lO7bfMJGaoiYseTWsKdkVGPVlpuRTB1pBJkU0tVWLLEY3SAds11On2wLBc/KRXHRzbXz6V1mg3fmx4J+YdKmporimtDoI9Nt9p3RqSfUVga1o0aqzRqPwroPPdFI4z61DIjzxnfjn0rkTadzFNnI6XeS6dKAc7c11tvr4lAO/A+tYV9ZrGp4GKxGdo/uMRWvKqmpVrnoX9prMww9Su6tHmuCt79wF+bpXQx6qv2YDdzionTa2JcbGf4gm8pgfWuc+2nPWr+s3X2jnNZ1laPdTqiqTmummrR1NIrQ07DVzbrgk/Wpr/wAQlrdlB5PHWtCDw7viAZCDiub1fR5rC62bWZG5U4pRUHIEk2Z8c8kl0rgndu4r0zSLuN7ZS2QSMnNcPp2kyPIrY5HNdvZ237oAKVIq5VYrQrmjcg1pg5Vx0HSrujzIVC7gOKo39ncynai/KKSxsp4JFYg4rCpaRM0uh16XC4C5qeCUO2CfpWNEjnnn61bh3RtuJ5FczSM1obojVlzSKBG+KqR3eQBmn+eS2AMijlVg5m9jQyGWs64DK5Iq1GxPBOKZcRhl96i1htOSM+60Sw1u2CXcf7xRhJU4dPx7j2NcjqPgm+syWiAuoOzRcMPqv+Ga7aLdD0zipJrgsmBTTa2KjOUDyxtMfftaPZj+8cH8qsxaewHB57sR0r0IRF/vqHB9Rmn/AGOEAMsEee+UFNuRusQ7bHE2mlDf+7RpHY84ySa6Kx8M3DkSTqIF65blvwFdPatsTCKEH+yMVLLJ8tS46XbE67M82VrYaXdCFcEwvuYn5mO09TXhHUc+gr33z0cbGwVPBHtXhWoWjWWp3No3DQysn4A8fpitsPJO6M076kG3IyTgDvVZiHbIzjoM13Nn4F82wglvbt4XddzRLHkrnpkk9cVj6v4afT/mgl8+L2XDA/St41I3C6MKJdvGO9XEG6Mcd8VAicY9PWrSKPLHJzVSY7kkeThFQliQAAMkmvTvD9w8GiWcM25XSIAh+COelc74a0mOFIr+dcysCY1I4Udm+tb0gdpOFO2uWp72xm2jp7W+TGMinT3akH5q5mDeH5z1rSRCw5pKdtCbEN7Pvz1xXJ31uZbxGA712UsGR0rInswZwAM96rm6l82ljQ0yzJhUHJ4resdJjds7BnqaqaUu2MKRW5ay+VKPQ1yXbkXGws2jwSwMjICCPSuIbRGtL+RAMx7sivSGlUrkVy+ocXRc9zXTaSiyppO1jKuLVDbkADgVwWsCK2uIicAljXa6pqcdrG5J4xjivOtRWfU7syAEDsPSqoXv7waI37W+jEYO4YqeXUEO0eprlktLuFfkycetQ+dOJPnyGFa+zTd0wep1/wBoDEBWwPatrS4F3qw57k1wUF65cHB+ldnot6rRhienasayaWglud1ZlQg9qsuysKwYb8AcciriXRIz1rllNpalrUvQN+9xWnFgDisWGQlskVqWjM7DJ+UVdN6CSsLPH5mc5LVT+wvnOK3ooRKxY9KfLAq4Aq+RSY7PcxooCOCKfLb71KkcEVbYhZsAipJQpxiqlDk2JWu5w2qaIZHZQMqexrhtU8GBLvzY49oPJxXtEkCuwytU7zTlYZ28YpxnJai5eiPnu/h8hQFGKxLjAXnrWhqt/wCa52E1jMxY5JJNdtNO2pKEBIOQeaCzNwTSgUoFaFAFJFRuCDVqMjFMkUdaE9R3K6g0pHFOOBS9qYrkByOlOVqHoUVQx5PFR+ZzQ5xUBJzSSBIuo/FNkc+tQo9DNmi2oWHoTnNW45XxjNU0PNWozQxMeULDJqEgqavoMiq8yVKYkyJXqUfNVbGDU6ZplAYyTxV/S7iS1uAQSKihjMjcCtu00nzE3Hr1rOcktwaNRdRLpycGlOo4H3qi8gQxYYA+9Yl9Kig7TWHIpaIz5dSfUdSEvyKeO9ZBmyeagLl2604wu33eSe1bxhyqxVieE5bNWt7KmBVa3tZiRxz6VfWFztULzn0pO1yWzLlR5G5zXR+HrIvIrIOVOc1OmkZiB2VqaPA1pJgDgnoaiU7qyFzX0OxtLNHtVcrVW/0uCaM5QEjkHFaFpOFhwemKqXd55fAXdmuOXMncT0KEWkRBASoB7cVPHaBDgAc1YSbzYx2o3DcB6daz95sm13dE0enoyZxzSfYBzuFXImJUENxTpHb+7+NapF2bKYs0UYqrPGIz7VcmnVR1wazLicyNgHikxcqFQZbA65rRj+VORWRDKVfGDmr0UrN+NKzYWsW1m2+9SCZJB978KoEEvmrMcIIz3prQuLEbaCfm6UwYY9eKfJGACM81CisC2egpLcT1LayooAbirEbIDxjFZDvufAqa1uMH5j+NaOnKcdCqckpamyrqR2qGeTCkA/hWTdaksMhVTjPSqiahI74POaxjTmtJBWnFvQ0WG85HBritY0tT8QLBmXK3CCZweQSmc/yFd1bKGUMTWDqlq0/jSxcDK29lI5PpltorSPutiSSQ+6uSB1Oaw7wuzbga1rvndxjFZDsG4J6dqqLRn1IY9Lsrtl8+3XPZkO3+Va1pomnWsvnR24L5BG47gv0FZyy7TkcelaVvcF8AiqYO+xpxFJH4HAq6IAQCBn1qhG2cbVwauRXLxrtahbjURxtQMEHnNT7SqcdRUAnAIJPFThg568VE1dgo9Bgl3Ng01YlaXJpjxkSFl6GpYPvEEVOxNjStV2kY6VoKcdazoJgv4VK05654pwSvcqzRptKBHye1czrt23lEIRntVmW+ZQfSuc1OR5mHYVpz6miehizP5rbHJYk85q7pulI8hYrx2qARfN05rqdHgCxjPXFZ1ZNLQtalSTRYwmdoArm73R18wtgYzXodyEEJziuWujuYrjkGsKcpLUppHL/2SYnDAfLWhaBrcgqOvar0rALhhzS26qz8CulTutSeU0baY7Pf0q5DeqjhGqqsTIMgcVk6ndSQzIIhls9PWsOVSkKzR2sFwrEDPWtS3m2OADxiuV0wyzhS3B9K3oYZg4bBxVSi0tCk0dNDcKkeWNVbq/MSO7HjtVOGCSWYZY4qzPpzTD1qINlvXYqWl207bjwTWqkZdQfSs6KyME+D3rVjbYuK2lNtamcYlfeUdie1Ry3UeCM1DqE4jYsvTHNcfd626swTGSfWpi7jl7p4G575zUeakfpUZr1RCinZpB0qRB8wpMT0FVGIyBUogLjng1dRQIxgVM8ahelZuRDZiywsh9qhJxWvcIuzpWRJ941pF3KRGeTTl9KVAM1JgYqmyiJlzUZiOatDpQQKVxXKyxcUMmDVoAYFMcCnfUdyAEg1ZiJqHABqeKh7CZbjfFK+GFRCpB0FTYlFcx4bNTRrxQ1LHSbKuXbJxHL8wGK6ayuYwh5HSuSyQOKek0i9HIrOceYVza1TUlVSFPNclNctIx5OM1Yu3Zs5JNUFGWrWEVFFGnpdt9pmAc8GvQdH0S1+UmNSfcVwmncSLivRNCdmQAsTU1GUlc1F8O2rAkRgfSqM3h1UlLJXTW5JQc0swGOlcku5nOCMax0/+F1BxUsukZlEgGMHtWnbgZNWiBs/CufnfMTGkmjJWNlBxzioJHHmbiMmtPaMHis26GGJFavVByjVw3XpSAkOeOKhjJLnJrRiVdvSojq7ESdtiS1LMyjPHpWwAuzBxmsSI7Z+OOa1UY460qqtsdeGs1qZOqxqsgINZyHGf51e1IlpeTmqC96mOwSilIniVc7u5rUt7cMmSKwo2InIzwCK6W1/1Yq72M42bIHh5+VflHWgERjnpWq6qIhgVm3AGOlaJJoTjqVbieMHKn61H542HpiqTdWqB3YR8E1LjysUYajbu/W2yc/MelT2t0rw5yB+Ncrfyu053MTjpWlan/RVrZT5ERNWeha1BxuL7uAKi0523DPPNQT8qc88d6NOZhJ1o5nJXIkr6nX2hO3rxUVwyLK8mPnZQpb2HQfTk02Bjs61X1BiE4NYSV2QmzNvLmPJGea52ecB2IP5GkvpZPNb5zWeCfm5q4wOhLQuJc7mrYsboKQXU49a5yPlzWpaswbGeMVbijNnaWey4UCMZNaA07cuTzWR4cJz+FdZGBtrJ6MqOuphy2mBgjpTNu3qcVrzqNx471l3Q+aj1CfcA/zKF5960Et96bh1rDtCfMbnoeK6a0/1QpPQUNdWZlwzRZJyCKqR3rTcZ6Vpaio8pjisCEYlOPWlGVzRrU03JMY4zkVn3NhNMPlzWtAAQMjtVy2RSpyB1rNyakUkcwNMmjIYgt+FbVkGWMHYelapjT+6OtESKBwBWjXMLZmbeyFosKeay0093JJPJNbkyL5p4FLGo+Xisamisiou7MK40oBM4OfWqMMJhnwe/SutuFG3pXP3gC3CY45qac3axUtC7Eu5Pu9qqnTBLcByvIPFXbToKvxAbulEG+YxkyzpWnIFGetdCluiIAo7Vm2vBGOK2E+7XSXFiW8Sqx9c1qRxoME1l5IdcetaBY7BzUbFp3KV4mJSw61k3l6UlCL1A5rTvHb1rClUG4JPWiWquJ6aFW9kkuoyinBPWuZvNKnjO9lyBXaxxqWHyipZ4o2j5QHilFCauf/Z\n"
-          },
-          "metadata": {},
-          "execution_count": 7
-        }
-      ]
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:root:[AgML] \n",
+      "    Dataset successfully exported to YOLO format. \n",
+      "\n",
+      "    You can find the dataset at the following location: /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide\n",
+      "    The dataset metadata is stored at /usr/local/lib/python3.10/dist-packages/ultralytics/data/dataset.yaml\n",
+      "    \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s.pt to 'yolo11s.pt'...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 18.4M/18.4M [00:00<00:00, 147MB/s] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ultralytics 8.3.23 🚀 Python-3.10.12 torch-2.5.0+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+      "\u001b[34m\u001b[1mengine/trainer: \u001b[0mtask=detect, mode=train, model=yolo11s.pt, data=/usr/local/lib/python3.10/dist-packages/ultralytics/data/dataset.yaml, epochs=50, time=None, patience=100, batch=16, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=8, project=None, name=train, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=True, opset=None, workspace=4, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, copy_paste_mode=flip, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs/detect/train\n",
+      "Downloading https://ultralytics.com/assets/Arial.ttf to '/root/.config/Ultralytics/Arial.ttf'...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 755k/755k [00:00<00:00, 21.5MB/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overriding model.yaml nc=80 with nc=7\n",
+      "\n",
+      "                   from  n    params  module                                       arguments                     \n",
+      "  0                  -1  1       928  ultralytics.nn.modules.conv.Conv             [3, 32, 3, 2]                 \n",
+      "  1                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]                \n",
+      "  2                  -1  1     26080  ultralytics.nn.modules.block.C3k2            [64, 128, 1, False, 0.25]     \n",
+      "  3                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              \n",
+      "  4                  -1  1    103360  ultralytics.nn.modules.block.C3k2            [128, 256, 1, False, 0.25]    \n",
+      "  5                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              \n",
+      "  6                  -1  1    346112  ultralytics.nn.modules.block.C3k2            [256, 256, 1, True]           \n",
+      "  7                  -1  1   1180672  ultralytics.nn.modules.conv.Conv             [256, 512, 3, 2]              \n",
+      "  8                  -1  1   1380352  ultralytics.nn.modules.block.C3k2            [512, 512, 1, True]           \n",
+      "  9                  -1  1    656896  ultralytics.nn.modules.block.SPPF            [512, 512, 5]                 \n",
+      " 10                  -1  1    990976  ultralytics.nn.modules.block.C2PSA           [512, 512, 1]                 \n",
+      " 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          \n",
+      " 12             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           \n",
+      " 13                  -1  1    443776  ultralytics.nn.modules.block.C3k2            [768, 256, 1, False]          \n",
+      " 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          \n",
+      " 15             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           \n",
+      " 16                  -1  1    127680  ultralytics.nn.modules.block.C3k2            [512, 128, 1, False]          \n",
+      " 17                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              \n",
+      " 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           \n",
+      " 19                  -1  1    345472  ultralytics.nn.modules.block.C3k2            [384, 256, 1, False]          \n",
+      " 20                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              \n",
+      " 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           \n",
+      " 22                  -1  1   1511424  ultralytics.nn.modules.block.C3k2            [768, 512, 1, True]           \n",
+      " 23        [16, 19, 22]  1    822117  ultralytics.nn.modules.head.Detect           [7, [128, 256, 512]]          \n",
+      "YOLO11s summary: 319 layers, 9,430,501 parameters, 9,430,485 gradients, 21.6 GFLOPs\n",
+      "\n",
+      "Transferred 493/499 items from pretrained weights\n",
+      "\u001b[34m\u001b[1mTensorBoard: \u001b[0mStart with 'tensorboard --logdir runs/detect/train', view at http://localhost:6006/\n",
+      "Freezing layer 'model.23.dfl.conv.weight'\n",
+      "\u001b[34m\u001b[1mAMP: \u001b[0mrunning Automatic Mixed Precision (AMP) checks...\n",
+      "Downloading https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt to 'yolo11n.pt'...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 5.35M/5.35M [00:00<00:00, 50.5MB/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34m\u001b[1mAMP: \u001b[0mchecks passed ✅\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34m\u001b[1mtrain: \u001b[0mScanning /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide/labels... 453 images, 0 backgrounds, 0 corrupt: 100%|██████████| 453/453 [00:00<00:00, 487.43it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34m\u001b[1mtrain: \u001b[0mNew cache created: /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide/labels.cache\n",
+      "\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34m\u001b[1mval: \u001b[0mScanning /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide/labels... 56 images, 0 backgrounds, 0 corrupt: 100%|██████████| 56/56 [00:00<00:00, 356.18it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34m\u001b[1mval: \u001b[0mNew cache created: /usr/local/lib/python3.10/dist-packages/ultralytics/datasets/fruit_detection_worldwide/labels.cache\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting labels to runs/detect/train/labels.jpg... \n",
+      "\u001b[34m\u001b[1moptimizer:\u001b[0m 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... \n",
+      "\u001b[34m\u001b[1moptimizer:\u001b[0m AdamW(lr=0.000909, momentum=0.9) with parameter groups 81 weight(decay=0.0), 88 weight(decay=0.0005), 87 bias(decay=0.0)\n",
+      "\u001b[34m\u001b[1mTensorBoard: \u001b[0mmodel graph visualization added ✅\n",
+      "Image sizes 640 train, 640 val\n",
+      "Using 2 dataloader workers\n",
+      "Logging results to \u001b[1mruns/detect/train\u001b[0m\n",
+      "Starting training for 50 epochs...\n",
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       1/50      4.49G      2.025      2.955      1.829         42        640: 100%|██████████| 29/29 [00:21<00:00,  1.36it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:02<00:00,  1.29s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.381      0.291      0.264      0.143\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       2/50      4.41G      1.611      1.901      1.497         89        640: 100%|██████████| 29/29 [00:17<00:00,  1.64it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.41it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323        0.5      0.274      0.314      0.159\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       3/50      4.44G       1.53       1.62      1.394         95        640: 100%|██████████| 29/29 [00:15<00:00,  1.87it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.25it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.507      0.457      0.411      0.224\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       4/50      4.46G      1.499       1.55      1.383         37        640: 100%|██████████| 29/29 [00:16<00:00,  1.73it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.84it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.617      0.442      0.456      0.259\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       5/50      4.38G      1.479      1.473       1.35         35        640: 100%|██████████| 29/29 [00:16<00:00,  1.74it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.22it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.396      0.443      0.388      0.212\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       6/50      4.44G      1.432      1.409       1.36         58        640: 100%|██████████| 29/29 [00:16<00:00,  1.77it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.25it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.648      0.448      0.522       0.28\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       7/50      4.44G      1.417      1.358        1.3         57        640: 100%|██████████| 29/29 [00:16<00:00,  1.76it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.11it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.618      0.577      0.586      0.335\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       8/50      4.43G      1.408      1.337      1.316         62        640: 100%|██████████| 29/29 [00:16<00:00,  1.72it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.02it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.518      0.517      0.486      0.271\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "       9/50      4.41G       1.37      1.317      1.315         45        640: 100%|██████████| 29/29 [00:16<00:00,  1.72it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.04it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.468      0.611      0.576      0.343\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      10/50      4.44G      1.373      1.259      1.285         37        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.57it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.579      0.553      0.573      0.341\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      11/50      4.42G      1.376      1.242       1.27         39        640: 100%|██████████| 29/29 [00:15<00:00,  1.85it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.44it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323       0.65      0.447      0.506      0.303\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      12/50      4.44G      1.327      1.203      1.265         32        640: 100%|██████████| 29/29 [00:16<00:00,  1.72it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.74it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.573      0.656      0.604      0.333\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      13/50      4.39G      1.328      1.215      1.257         32        640: 100%|██████████| 29/29 [00:17<00:00,  1.64it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.07it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.636      0.677       0.67      0.396\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      14/50      4.46G      1.296       1.11      1.252         46        640: 100%|██████████| 29/29 [00:18<00:00,  1.60it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.67it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.581      0.581      0.583      0.348\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      15/50      4.46G      1.285      1.078      1.227         45        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.37it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.701      0.671      0.704      0.396\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      16/50      4.46G       1.27      1.104       1.22         35        640: 100%|██████████| 29/29 [00:16<00:00,  1.72it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.15it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.674      0.541      0.628      0.365\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      17/50      4.38G      1.314      1.122      1.234         60        640: 100%|██████████| 29/29 [00:16<00:00,  1.73it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.25it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.593      0.578      0.594       0.33\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      18/50      4.46G      1.246      1.053      1.218         71        640: 100%|██████████| 29/29 [00:16<00:00,  1.74it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.11it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323       0.68      0.681      0.739      0.461\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      19/50      4.46G      1.239      1.026      1.207         83        640: 100%|██████████| 29/29 [00:15<00:00,  1.92it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.56it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.657      0.664      0.712      0.431\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      20/50      4.42G      1.252     0.9774      1.189         54        640: 100%|██████████| 29/29 [00:15<00:00,  1.88it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.36it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.701      0.673      0.723      0.445\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      21/50      4.42G      1.214     0.9525      1.174         58        640: 100%|██████████| 29/29 [00:15<00:00,  1.90it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.36it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.735      0.657      0.726      0.433\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      22/50      4.41G        1.2     0.9505      1.178         60        640: 100%|██████████| 29/29 [00:16<00:00,  1.80it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.05it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.702      0.637      0.705      0.436\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      23/50      4.44G      1.189     0.9472      1.186         34        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.15it/s]"
+     ]
     },
     {
-      "cell_type": "markdown",
-      "source": [
-        "## Integration with Annotation Tools\n",
-        "\n",
-        "If you're using the CVAT annotation tool, you can export annotations to the `COCO 1.0` format, then use `agml.data.extensions.restructure_cvat_annotations(\"image_folder\", \"annotation_folder\", \"dataset_name\")` to set up the annotations in a format ready to use in AgML."
-      ],
-      "metadata": {
-        "id": "5Gq0ArfPhGKt"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.753      0.689      0.757      0.427\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      24/50      4.41G      1.184     0.9425      1.171         57        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.21it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323       0.81       0.67      0.758      0.467\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      25/50      4.35G      1.154     0.8815       1.16         71        640: 100%|██████████| 29/29 [00:17<00:00,  1.64it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.52it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.691       0.69      0.737      0.473\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      26/50      4.45G      1.172      0.892       1.17         39        640: 100%|██████████| 29/29 [00:17<00:00,  1.67it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.28it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.707      0.677      0.759      0.468\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      27/50      4.46G      1.154     0.8552      1.161         38        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.16it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.726      0.713      0.788      0.501\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      28/50      4.41G      1.141     0.8557      1.153         35        640: 100%|██████████| 29/29 [00:15<00:00,  1.82it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.71it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.723      0.765      0.799      0.497\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      29/50      4.37G      1.131     0.8527      1.141         64        640: 100%|██████████| 29/29 [00:15<00:00,  1.85it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.46it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.782      0.726      0.796      0.482\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      30/50      4.42G      1.121     0.8314      1.122         35        640: 100%|██████████| 29/29 [00:14<00:00,  1.98it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.33it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323       0.79      0.674      0.763      0.471\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      31/50      4.44G      1.127     0.7884      1.133         54        640: 100%|██████████| 29/29 [00:15<00:00,  1.85it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.09it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.743      0.676      0.738      0.448\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      32/50      4.46G      1.074     0.7499      1.101         36        640: 100%|██████████| 29/29 [00:17<00:00,  1.69it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.36it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.662      0.731      0.725      0.435\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      33/50      4.39G      1.081     0.7667      1.121         41        640: 100%|██████████| 29/29 [00:16<00:00,  1.75it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.09it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.781       0.76      0.806      0.476\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      34/50      4.46G      1.058     0.7319      1.115         44        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.44it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.732      0.704      0.767      0.471\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      35/50      4.41G      1.086     0.7611      1.108         51        640: 100%|██████████| 29/29 [00:16<00:00,  1.80it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.31it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.759      0.703      0.751      0.435\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      36/50       4.4G      1.048     0.7387      1.102         53        640: 100%|██████████| 29/29 [00:16<00:00,  1.81it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.26it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.778      0.662      0.757      0.458\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      37/50      4.39G      1.067     0.7336      1.105         51        640: 100%|██████████| 29/29 [00:16<00:00,  1.73it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.52it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.827      0.763      0.835        0.5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      38/50      4.41G      1.049     0.7282      1.104         38        640: 100%|██████████| 29/29 [00:16<00:00,  1.76it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.80it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.771      0.809      0.846      0.509\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      39/50      4.46G      1.023     0.6731      1.074         62        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.41it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.782      0.785      0.822       0.49\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      40/50      4.41G      1.008     0.6794      1.091         41        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.57it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323       0.77      0.752      0.813      0.515\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Closing dataloader mosaic\n",
+      "\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))\n",
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      41/50      4.38G     0.9742     0.6427      1.074         28        640: 100%|██████████| 29/29 [00:20<00:00,  1.43it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.16it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.815      0.704      0.786      0.498\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      42/50      4.41G     0.9406     0.5991      1.056         29        640: 100%|██████████| 29/29 [00:16<00:00,  1.75it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.12it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323       0.75      0.723      0.775      0.495\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      43/50      4.43G     0.9236     0.5617      1.054         26        640: 100%|██████████| 29/29 [00:16<00:00,  1.74it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.03it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.771      0.768      0.799      0.507\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      44/50      4.42G     0.9307      0.546      1.046         41        640: 100%|██████████| 29/29 [00:16<00:00,  1.77it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.27it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.779       0.77      0.802      0.494\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      45/50      4.41G     0.9276     0.5584      1.063         20        640: 100%|██████████| 29/29 [00:16<00:00,  1.74it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.54it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.748      0.779       0.79      0.494\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      46/50      4.42G     0.8934     0.5168      1.029         25        640: 100%|██████████| 29/29 [00:15<00:00,  1.85it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.22it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.829       0.73      0.815      0.508\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      47/50      4.42G     0.8831     0.5218      1.025         25        640: 100%|██████████| 29/29 [00:16<00:00,  1.78it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.34it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.784      0.774      0.825      0.511\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      48/50      4.44G     0.8758     0.5143      1.032         24        640: 100%|██████████| 29/29 [00:17<00:00,  1.70it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.17it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.795       0.78      0.826      0.525\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      49/50      4.38G     0.8788     0.4938      1.034         21        640: 100%|██████████| 29/29 [00:15<00:00,  1.93it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.55it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.785      0.776      0.821       0.52\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "      50/50      4.41G     0.8503     0.5063      1.017         45        640: 100%|██████████| 29/29 [00:14<00:00,  1.95it/s]\n",
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:01<00:00,  1.46it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.795      0.765      0.827       0.52\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "50 epochs completed in 0.280 hours.\n",
+      "Optimizer stripped from runs/detect/train/weights/last.pt, 19.2MB\n",
+      "Optimizer stripped from runs/detect/train/weights/best.pt, 19.2MB\n",
+      "\n",
+      "Validating runs/detect/train/weights/best.pt...\n",
+      "Ultralytics 8.3.23 🚀 Python-3.10.12 torch-2.5.0+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+      "YOLO11s summary (fused): 238 layers, 9,415,509 parameters, 0 gradients, 21.3 GFLOPs\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 2/2 [00:00<00:00,  2.07it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                   all         56        323      0.797      0.779      0.826      0.525\n",
+      "               avocado          7         41       0.72       0.78      0.767      0.465\n",
+      "             rockmelon          6         13      0.907       0.75      0.896       0.51\n",
+      "                 apple          6         38      0.723      0.895      0.894      0.637\n",
+      "                orange          7         24      0.746      0.611      0.711      0.415\n",
+      "            strawberry          3         50      0.835      0.812      0.849      0.576\n",
+      "                 mango         14         91      0.859      0.934      0.956      0.678\n",
+      "              capsicum         13         66      0.787      0.671      0.708      0.393\n",
+      "Speed: 0.2ms preprocess, 5.8ms inference, 0.0ms loss, 1.8ms postprocess per image\n",
+      "Results saved to \u001b[1mruns/detect/train\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:root:[AgML] Model training complete. Model saved to: /root/.agml/models/detectors/fruit_test\n",
+      "\n",
+      "        For full Ultralytics training logs and outputs, see: runs/detect/train\n",
+      "\n",
+      "        To load the AgML model directly, you can run: \n",
+      "\n",
+      "        import agml.models\n",
+      "        model = agml.models.Detector('fruit_test')\n",
+      "\n",
+      "        and the model with the best weights from this training run will be loaded.\n",
+      "        \n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.google.colaboratory.intrinsic+json": {
+       "type": "string"
       },
-      "id": "5Gq0ArfPhGKt"
+      "text/plain": [
+       "'fruit_test'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
     }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "Python 3",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.9.6"
-    },
+   ],
+   "source": [
+    "loader = agml.data.AgMLDataLoader(\"fruit_detection_worldwide\")\n",
+    "loader.split(train=0.8, val=0.1, test=0.1)\n",
+    "agml.models.Detector.train(loader, \"yolo11s\", epochs=50, run_name=\"fruit_test\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bAOlxF-ChXGe",
+   "metadata": {
+    "id": "bAOlxF-ChXGe"
+   },
+   "source": [
+    "## Inference\n",
+    "\n",
+    "You can run inference simply with `agml.models.Detector.load()`, to load the name of your saved model. and then either `Detector.show_prediction()` for visualization, or `Detector.predict()` to get the bounding boxes, labels, and confidence values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "AHAVxV6GTTaH",
+   "metadata": {
+    "id": "AHAVxV6GTTaH"
+   },
+   "outputs": [],
+   "source": [
+    "model = agml.models.Detector.load(\"fruit_test\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "J3UwEF3kWtIL",
+   "metadata": {
     "colab": {
-      "provenance": [],
-      "gpuType": "T4"
+     "base_uri": "https://localhost:8080/",
+     "height": 444
     },
-    "accelerator": "GPU"
+    "id": "J3UwEF3kWtIL",
+    "outputId": "b4a8cf47-cdf5-4abc-e2a8-69279c05a53e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "image/png": "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\n",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=640x427>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Image.fromarray(model.show_prediction(loader[1][0]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5Gq0ArfPhGKt",
+   "metadata": {
+    "id": "5Gq0ArfPhGKt"
+   },
+   "source": [
+    "## Integration with Annotation Tools\n",
+    "\n",
+    "If you're using the CVAT annotation tool, you can export annotations to the `COCO 1.0` format, then use `agml.data.extensions.restructure_cvat_annotations(\"image_folder\", \"annotation_folder\", \"dataset_name\")` to set up the annotations in a format ready to use in AgML."
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
   },
-  "nbformat": 4,
-  "nbformat_minor": 5
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
 }
\ No newline at end of file
diff --git a/examples/AgML-Models.ipynb b/examples/AgML-Models.ipynb
index 0e066acc..03c3f51c 100644
--- a/examples/AgML-Models.ipynb
+++ b/examples/AgML-Models.ipynb
@@ -69,11 +69,11 @@
    },
    "outputs": [],
    "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
     "import agml\n",
     "import agml.models\n",
     "\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
     "%matplotlib inline\n",
     "%load_ext autoreload\n",
     "%autoreload 2"
@@ -130,13 +130,15 @@
    ],
    "source": [
     "# Construct a one-class model.\n",
-    "detector = agml.models.DetectionModel(num_classes = 1)\n",
+    "detector = agml.models.DetectionModel(num_classes=1)\n",
     "\n",
     "# Visualize predictions.\n",
-    "grape_day = agml.data.AgMLDataLoader('mango_detection_australia')\n",
+    "grape_day = agml.data.AgMLDataLoader(\"mango_detection_australia\")\n",
     "image, truth = grape_day[0]\n",
     "pred_boxes, *_ = detector.predict(image)\n",
-    "_ = agml.viz.show_object_detection_truth_and_prediction(image, real_boxes = truth, predicted_boxes = pred_boxes)"
+    "_ = agml.viz.show_object_detection_truth_and_prediction(\n",
+    "    image, real_boxes=truth, predicted_boxes=pred_boxes\n",
+    ")"
    ]
   },
   {
@@ -173,12 +175,14 @@
    ],
    "source": [
     "# Load the `mango_detection_australia` benchmark.\n",
-    "detector.load_benchmark('mango_detection_australia')\n",
+    "detector.load_benchmark(\"mango_detection_australia\")\n",
     "\n",
     "# Visualize predictions.\n",
     "image, truth = grape_day[0]\n",
     "pred_boxes, *_ = detector.predict(image)\n",
-    "_ = agml.viz.show_object_detection_truth_and_prediction(image, real_boxes = truth, predicted_boxes = pred_boxes)"
+    "_ = agml.viz.show_object_detection_truth_and_prediction(\n",
+    "    image, real_boxes=truth, predicted_boxes=pred_boxes\n",
+    ")"
    ]
   },
   {
@@ -267,21 +271,25 @@
    ],
    "source": [
     "# Construct a one-class model.\n",
-    "seg = agml.models.SegmentationModel(num_classes = 1)\n",
+    "seg = agml.models.SegmentationModel(num_classes=1)\n",
     "\n",
     "# Visualize predictions.\n",
-    "apple_flower = agml.data.AgMLDataLoader('apple_flower_segmentation')\n",
+    "apple_flower = agml.data.AgMLDataLoader(\"apple_flower_segmentation\")\n",
     "image, truth = apple_flower[0]\n",
     "pred_mask = seg.predict(image)\n",
-    "_ = agml.viz.show_semantic_segmentation_truth_and_prediction(image, real_mask = truth, predicted_mask = pred_mask)\n",
+    "_ = agml.viz.show_semantic_segmentation_truth_and_prediction(\n",
+    "    image, real_mask=truth, predicted_mask=pred_mask\n",
+    ")\n",
     "\n",
     "# Load the `apple_flower_segmentation` benchmark.\n",
-    "seg.load_benchmark('apple_flower_segmentation')\n",
+    "seg.load_benchmark(\"apple_flower_segmentation\")\n",
     "\n",
     "# Visualize predictions.\n",
     "image, truth = apple_flower[0]\n",
     "pred_mask = seg.predict(image)\n",
-    "_ = agml.viz.show_semantic_segmentation_truth_and_prediction(image, real_mask = truth, predicted_mask = pred_mask)"
+    "_ = agml.viz.show_semantic_segmentation_truth_and_prediction(\n",
+    "    image, real_mask=truth, predicted_mask=pred_mask\n",
+    ")"
    ]
   },
   {
@@ -332,12 +340,12 @@
    ],
    "source": [
     "# Construct a model with a benchmark for `fruit_detection_worldwide`.\n",
-    "detector = agml.models.DetectionModel(num_classes = 7)\n",
-    "detector.load_benchmark('fruit_detection_worldwide')\n",
-    "#detector.cuda()\n",
+    "detector = agml.models.DetectionModel(num_classes=7)\n",
+    "detector.load_benchmark(\"fruit_detection_worldwide\")\n",
+    "# detector.cuda()\n",
     "\n",
     "# Evaluate on a subset of the dataset.\n",
-    "dataset = agml.data.AgMLDataLoader('fruit_detection_worldwide').take_random(100)\n",
+    "dataset = agml.data.AgMLDataLoader(\"fruit_detection_worldwide\").take_random(100)\n",
     "result = detector.evaluate(dataset)\n",
     "print(f\"Calculated Mean Average Precision: {result.numpy() * 100}%\")"
    ]
@@ -391,11 +399,11 @@
    ],
    "source": [
     "# Construct a model with a benchmark for `rice_seedling_segmentation`.\n",
-    "seg = agml.models.SegmentationModel(num_classes = 1)\n",
-    "seg.load_benchmark('apple_segmentation_minnesota')\n",
+    "seg = agml.models.SegmentationModel(num_classes=1)\n",
+    "seg.load_benchmark(\"apple_segmentation_minnesota\")\n",
     "\n",
     "# Evaluate on a subset of the dataset.\n",
-    "dataset = agml.data.AgMLDataLoader('apple_segmentation_minnesota').take_random(50)\n",
+    "dataset = agml.data.AgMLDataLoader(\"apple_segmentation_minnesota\").take_random(50)\n",
     "result = seg.evaluate(dataset)\n",
     "print(f\"Calculated intersection-over-union: {result * 100}%\")"
    ]
@@ -444,13 +452,15 @@
     "import albumentations as A\n",
     "\n",
     "# Construct a loader and apply the preprocessor.\n",
-    "loader = agml.data.AgMLDataLoader('grape_detection_californiaday')\n",
-    "processor = agml.models.preprocessing.EfficientDetPreprocessor(image_size = 512, augmentation = [A.RandomRotate90()])\n",
-    "loader.transform(dual_transform = processor)\n",
+    "loader = agml.data.AgMLDataLoader(\"grape_detection_californiaday\")\n",
+    "processor = agml.models.preprocessing.EfficientDetPreprocessor(\n",
+    "    image_size=512, augmentation=[A.RandomRotate90()]\n",
+    ")\n",
+    "loader.transform(dual_transform=processor)\n",
     "\n",
     "# Inspect a data sample.\n",
     "image, truth = loader[0]\n",
-    "_ = agml.viz.show_image_and_boxes(image, truth, bbox_format = 'efficientdet')"
+    "_ = agml.viz.show_image_and_boxes(image, truth, bbox_format=\"efficientdet\")"
    ]
   },
   {
diff --git a/examples/AgML-Synthetic.ipynb b/examples/AgML-Synthetic.ipynb
index 156b8f4e..9986f652 100644
--- a/examples/AgML-Synthetic.ipynb
+++ b/examples/AgML-Synthetic.ipynb
@@ -42,10 +42,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import agml\n",
-    "\n",
     "from pprint import pprint\n",
     "\n",
+    "import agml\n",
+    "\n",
     "%matplotlib inline"
    ]
   },
@@ -125,7 +125,7 @@
    ],
    "source": [
     "# Let's use the Tomato canopy.\n",
-    "pprint(agml.synthetic.default_canopy_parameters('Tomato'))"
+    "pprint(agml.synthetic.default_canopy_parameters(\"Tomato\"))"
    ]
   },
   {
@@ -145,7 +145,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "opt = agml.synthetic.HeliosOptions('Tomato')"
+    "opt = agml.synthetic.HeliosOptions(\"Tomato\")"
    ]
   },
   {
@@ -163,7 +163,7 @@
    "source": [
     "# Creating a semantic segmentation task with fruits and leaves labeled.\n",
     "opt.annotation_type = agml.synthetic.AnnotationType.semantic_segmentation\n",
-    "opt.labels = ['fruits', 'leaves']"
+    "opt.labels = [\"fruits\", \"leaves\"]"
    ]
   },
   {
@@ -182,7 +182,7 @@
    "outputs": [],
    "source": [
     "# Generate camera position vectors and select image resolution.\n",
-    "opt.camera.generate_positions(camera_type = 'circular', num_views = 3, crop_distance = 3)\n",
+    "opt.camera.generate_positions(camera_type=\"circular\", num_views=3, crop_distance=3)\n",
     "opt.camera.image_resolution = [512, 512]"
    ]
   },
@@ -322,7 +322,7 @@
     "generator = agml.synthetic.HeliosDataGenerator(opt)\n",
     "\n",
     "# Generate the data.\n",
-    "generator.generate(name = 'tomato_sample', num_images = 3, clear_existing_files=True)"
+    "generator.generate(name=\"tomato_sample\", num_images=3, clear_existing_files=True)"
    ]
   },
   {
@@ -343,7 +343,7 @@
    },
    "outputs": [],
    "source": [
-    "loader = agml.data.AgMLDataLoader.helios('tomato_sample')\n",
+    "loader = agml.data.AgMLDataLoader.helios(\"tomato_sample\")\n",
     "_ = agml.viz.show_image_and_mask(loader[0])"
    ]
   },
diff --git a/experiments/benchmarking/accuracy_evaluation.py b/experiments/benchmarking/accuracy_evaluation.py
index 1b886c10..dc7f4dd6 100644
--- a/experiments/benchmarking/accuracy_evaluation.py
+++ b/experiments/benchmarking/accuracy_evaluation.py
@@ -12,23 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import os
 
 import numpy as np
 import pandas as pd
-from tqdm import tqdm
-
-import torch
 import pytorch_lightning as pl
-
-import agml
+import torch
 from classification_lightning import ClassificationBenchmark
 from torchmetrics import Accuracy
+from tqdm import tqdm
 
+import agml
 
 # Define device.
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 
 def run_evaluation(model, name):
@@ -38,17 +36,17 @@ def run_evaluation(model, name):
     loader = agml.data.AgMLDataLoader(name)
     loader.shuffle()
     loader.split(0.8, 0.1, 0.1)
-    loader.batch(batch_size = 16)
-    loader.resize_images('imagenet')
-    loader.normalize_images('imagenet')
+    loader.batch(batch_size=16)
+    loader.resize_images("imagenet")
+    loader.normalize_images("imagenet")
     loader.labels_to_one_hot()
     ds = loader.test_data.as_torch_dataset()
 
     # Create the metric.
-    acc = Accuracy(num_classes = loader.num_classes)
+    acc = Accuracy(num_classes=loader.num_classes)
 
     # Run inference for all of the images in the test dataset.
-    for i in tqdm(range(len(ds)), leave = False):
+    for i in tqdm(range(len(ds)), leave=False):
         image, y = ds[i]
         y_pred = model(image.to(device))
         acc(y_pred.detach().cpu(), torch.argmax(y, 1).cpu())
@@ -60,21 +58,22 @@ def run_evaluation(model, name):
 def make_checkpoint(name):
     """Gets a checkpoint for the model name."""
     ckpt_path = os.path.join(
-        "/data2/amnjoshi/final/classification_checkpoints", name, "final_model.pth")
-    state = torch.load(ckpt_path, map_location = 'cpu')
-    model = ClassificationBenchmark(dataset = name)
+        "/data2/amnjoshi/final/classification_checkpoints", name, "final_model.pth"
+    )
+    state = torch.load(ckpt_path, map_location="cpu")
+    model = ClassificationBenchmark(dataset=name)
     model.load_state_dict(state)
     model.eval().to(device)
     return model
 
 
-def evaluate(names, log_file = None):
+def evaluate(names, log_file=None):
     """Runs the evaluation and saves results to a file."""
     print(f"Running accuracy evaluation for {names}.")
 
     # Create the log file.
     if log_file is None:
-        log_file = os.path.join(os.getcwd(), 'accuracy_evaluation.csv')
+        log_file = os.path.join(os.getcwd(), "accuracy_evaluation.csv")
 
     # Run the evaluation.
     log_contents = {}
@@ -82,43 +81,43 @@ def evaluate(names, log_file = None):
     for name in bar:
         ckpt = make_checkpoint(name)
         bar.set_description(f"Evaluating {name}")
-        if hasattr(name, 'name'):
+        if hasattr(name, "name"):
             name = name.name
         log_contents[name] = run_evaluation(ckpt, name)
 
     # Save the results.
-    df = pd.DataFrame(columns = ('name', 'accuracy'))
+    df = pd.DataFrame(columns=("name", "accuracy"))
     for name, value in log_contents.items():
         df.loc[len(df.index)] = [name, value]
     df.to_csv(log_file)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--log_file', type = str, default = None,
-        help = "The name of the output log file.")
+        "--log_file", type=str, default=None, help="The name of the output log file."
+    )
     args = ap.parse_args()
 
     # Train the model.
-    if args.dataset[0] in agml.data.public_data_sources(ml_task = 'image_classification'):
+    if args.dataset[0] in agml.data.public_data_sources(ml_task="image_classification"):
         datasets = args.dataset[0]
     else:
-        if args.dataset[0] == 'all':
-            datasets = [ds for ds in agml.data.public_data_sources(
-                ml_task = 'image_classification')]
-        elif args.dataset[0] == 'except':
+        if args.dataset[0] == "all":
+            datasets = [
+                ds
+                for ds in agml.data.public_data_sources(ml_task="image_classification")
+            ]
+        elif args.dataset[0] == "except":
             exclude_datasets = args.dataset[1:]
             datasets = [
-                dataset for dataset in agml.data.public_data_sources(
-                    ml_task = 'image_classification')
-                if dataset.name not in exclude_datasets]
+                dataset
+                for dataset in agml.data.public_data_sources(
+                    ml_task="image_classification"
+                )
+                if dataset.name not in exclude_datasets
+            ]
         else:
             datasets = args.dataset
     evaluate(datasets, args.log_file)
-
-
-
-
diff --git a/experiments/benchmarking/classification.py b/experiments/benchmarking/classification.py
index b8ba2585..f884c519 100644
--- a/experiments/benchmarking/classification.py
+++ b/experiments/benchmarking/classification.py
@@ -12,18 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import argparse
 import os
 import sys
 from enum import Enum
-import argparse
 
+import albumentations as A
+import numpy as np
 import torch
 import torch.nn as nn
 from torchvision.models import efficientnet_b4
-
-import numpy as np
 from tqdm import tqdm
-import albumentations as A
 
 import agml
 from agml.utils.io import recursive_dirname
@@ -35,15 +34,16 @@ class EfficientNetB4Transfer(nn.Module):
     This is the base benchmarking model for image classification, using
     the EfficientNetB4 model with two added linear fully-connected layers.
     """
-    def __init__(self, num_classes, pretrained = True):
+
+    def __init__(self, num_classes, pretrained=True):
         super(EfficientNetB4Transfer, self).__init__()
-        self.base = efficientnet_b4(pretrained = pretrained)
+        self.base = efficientnet_b4(pretrained=pretrained)
         self.l1 = nn.Linear(1000, 256)
         self.dropout = nn.Dropout(0.1)
         self.relu = nn.ReLU()
         self.l2 = nn.Linear(256, num_classes)
 
-    def forward(self, x, **kwargs): # noqa
+    def forward(self, x, **kwargs):  # noqa
         x = self.base(x)
         x = x.view(x.size(0), -1)
         x = self.dropout(self.relu(self.l1(x)))
@@ -60,13 +60,13 @@ def build_loaders(name):
     the imagenet standard. Labels vectors are converted to one-hot.
     """
     loader = agml.data.AgMLDataLoader(name)
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
-    loader.batch(batch_size = 16)
-    loader.resize_images('imagenet')
-    loader.normalize_images('imagenet')
+    loader.split(train=0.8, val=0.1, test=0.1)
+    loader.batch(batch_size=16)
+    loader.resize_images("imagenet")
+    loader.normalize_images("imagenet")
     loader.labels_to_one_hot()
     train_data = loader.train_data
-    train_data.transform(transform = A.RandomRotate90())
+    train_data.transform(transform=A.RandomRotate90())
     train_ds = train_data.copy().as_torch_dataset()
     val_ds = loader.val_data.as_torch_dataset()
     test_ds = loader.test_data.as_torch_dataset()
@@ -76,33 +76,26 @@ def build_loaders(name):
 # Create the training loop.
 class Trainer(object):
     """Trains a model and saves checkpoints to a save directory."""
-    def __init__(self, checkpoint_dir = None):
+
+    def __init__(self, checkpoint_dir=None):
         # Build the checkpoint directory.
         if checkpoint_dir is None:
-            checkpoint_dir = os.path.join(
-                recursive_dirname(__file__, 4), 'checkpoints')
+            checkpoint_dir = os.path.join(recursive_dirname(__file__, 4), "checkpoints")
         self._checkpoint_dir = checkpoint_dir
         self._saved_checkpoints = dict()
 
-    def fit(self,
-            model,
-            train_ds,
-            val_ds,
-            epochs = 50,
-            log = False,
-            **kwargs):
+    def fit(self, model, train_ds, val_ds, epochs=50, log=False, **kwargs):
         """Trains the model on the provided data loaders."""
         # Set up the checkpoint tracking.
-        save_all = kwargs.pop('save_all', False)
-        self._checkpoint_dir = os.path.join(
-            self._checkpoint_dir, kwargs['dataset'])
-        os.makedirs(self._checkpoint_dir, exist_ok = True)
+        save_all = kwargs.pop("save_all", False)
+        self._checkpoint_dir = os.path.join(self._checkpoint_dir, kwargs["dataset"])
+        os.makedirs(self._checkpoint_dir, exist_ok=True)
         if log:
-            log_file = os.path.join(self._checkpoint_dir, 'log.txt')
-            open(log_file, 'w').close()
+            log_file = os.path.join(self._checkpoint_dir, "log.txt")
+            open(log_file, "w").close()
 
         # Determine if a GPU exists.
-        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         model = model.to(device)
 
         # Create the optimizer and loss.
@@ -110,8 +103,10 @@ def fit(self,
         criterion = nn.CrossEntropyLoss()
 
         # Initialize training state variables.
-        print(f"Training EfficientNetB4 on '{kwargs['dataset']}': "
-              f"{epochs} epochs, writing checkpoints to {self._checkpoint_dir}.")
+        print(
+            f"Training EfficientNetB4 on '{kwargs['dataset']}': "
+            f"{epochs} epochs, writing checkpoints to {self._checkpoint_dir}."
+        )
         model.train()
 
         # Start the training loop.
@@ -121,8 +116,9 @@ def fit(self,
 
             # Iterate through the training data loader.
             model.train()
-            for (images, labels) in tqdm(
-                    train_ds, desc = f"Epoch {epoch + 1}/{epochs}", file = sys.stdout):
+            for images, labels in tqdm(
+                train_ds, desc=f"Epoch {epoch + 1}/{epochs}", file=sys.stdout
+            ):
                 # Move the data to the correct device.
                 images = images.to(device)
                 labels = labels.to(device)
@@ -144,7 +140,7 @@ def fit(self,
 
             # Iterate through the validation data loader.
             model.eval()
-            for (images, labels) in tqdm(val_ds, desc = "Validating"):
+            for images, labels in tqdm(val_ds, desc="Validating"):
                 # Move the data to the correct device.
                 images = images.to(device)
                 labels = labels.to(device)
@@ -165,24 +161,28 @@ def fit(self,
             final_val_loss = val_loss[-1]
             final_acc = (sum(acc) / len(acc)).item()
             final_val_acc = (sum(val_acc) / len(val_acc)).item()
-            print(f"\nAverage Loss: {train_loss:.4f}, "
-                  f"Average Accuracy: {final_acc:.4f}, ",
-                  f"Epoch Loss: {final_loss:.4f}, "
-                  f"Validation Accuracy: {final_val_acc:.4f}, "
-                  f"Validation Loss: {final_val_loss:.4f}")
+            print(
+                f"\nAverage Loss: {train_loss:.4f}, "
+                f"Average Accuracy: {final_acc:.4f}, ",
+                f"Epoch Loss: {final_loss:.4f}, "
+                f"Validation Accuracy: {final_val_acc:.4f}, "
+                f"Validation Loss: {final_val_loss:.4f}",
+            )
 
             # Save info to log file.
             if log:
-                with open(log_file, 'a') as f: # noqa
-                    f.write(f"Epoch {epoch}, "
-                            f"Average Loss: {train_loss.items():.4f}, "
-                            f"Epoch Loss: {final_loss:.4f}, "
-                            f"Validation Loss: {final_val_loss:.4f}\n")
+                with open(log_file, "a") as f:  # noqa
+                    f.write(
+                        f"Epoch {epoch}, "
+                        f"Average Loss: {train_loss.items():.4f}, "
+                        f"Epoch Loss: {final_loss:.4f}, "
+                        f"Validation Loss: {final_val_loss:.4f}\n"
+                    )
 
             # Save the checkpoint.
             save_path = os.path.join(
-                           self._checkpoint_dir,
-                           f"epoch_{epoch}_loss_{final_val_loss:.3f}.pth")
+                self._checkpoint_dir, f"epoch_{epoch}_loss_{final_val_loss:.3f}.pth"
+            )
             torch.save(model.state_dict(), save_path)
             if not save_all:
                 for path, loss in self._saved_checkpoints.items():
@@ -199,30 +199,32 @@ def accuracy(output, target):
         _, pred = torch.topk(output, 1, 1)
         pred = pred.t()
         correct = pred.eq(target.view(1, -1).expand_as(pred))
-        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim = True)
+        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim=True)
         return correct_k.mul_(100.0 / batch_size)
 
 
 def execute():
     # Parse command line arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, help = "The name of the dataset.")
-    ap.add_argument(
-        '--save_all', action = 'store_true', default = False, help = 'Save all checkpoints.')
+        "--save_all", action="store_true", default=False, help="Save all checkpoints."
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = '/data2/amnjoshi/checkpoints',
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default="/data2/amnjoshi/checkpoints",
+        help="The checkpoint directory to save to.",
+    )
     args = ap.parse_args()
 
     # Execute the program.
     train, val, test = build_loaders(args.dataset)
     net = EfficientNetB4Transfer(agml.data.source(args.dataset).num_classes)
-    Trainer(checkpoint_dir = args.checkpoint_dir).fit(
-        net, train_ds = train, val_ds = val,
-        dataset = args.dataset, save_all = args.save_all
+    Trainer(checkpoint_dir=args.checkpoint_dir).fit(
+        net, train_ds=train, val_ds=val, dataset=args.dataset, save_all=args.save_all
     )
 
-if __name__ == '__main__':
-    execute()
 
+if __name__ == "__main__":
+    execute()
diff --git a/experiments/benchmarking/classification_distributed.py b/experiments/benchmarking/classification_distributed.py
index 352141b8..329ce8eb 100644
--- a/experiments/benchmarking/classification_distributed.py
+++ b/experiments/benchmarking/classification_distributed.py
@@ -12,17 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import os
 
-import agml
 import albumentations as A
-
+import pytorch_lightning as pl
 import torch
 import torch.nn as nn
-import pytorch_lightning as pl
 from torchvision.models import efficientnet_b4
 
+import agml
+
 
 class EfficientNetB4Transfer(nn.Module):
     """Represents a transfer learning EfficientNetB4 model.
@@ -30,15 +30,16 @@ class EfficientNetB4Transfer(nn.Module):
     This is the base benchmarking model for image classification, using
     the EfficientNetB4 model with two added linear fully-connected layers.
     """
-    def __init__(self, num_classes, pretrained = True):
+
+    def __init__(self, num_classes, pretrained=True):
         super(EfficientNetB4Transfer, self).__init__()
-        self.base = efficientnet_b4(pretrained = pretrained)
+        self.base = efficientnet_b4(pretrained=pretrained)
         self.l1 = nn.Linear(1000, 256)
         self.dropout = nn.Dropout(0.1)
         self.relu = nn.ReLU()
         self.l2 = nn.Linear(256, num_classes)
 
-    def forward(self, x, **kwargs): # noqa
+    def forward(self, x, **kwargs):  # noqa
         x = self.base(x)
         x = x.view(x.size(0), -1)
         x = self.dropout(self.relu(self.l1(x)))
@@ -48,7 +49,7 @@ def forward(self, x, **kwargs): # noqa
 
 def get_num_gpus(args):
     """Resolves the number of GPUs to use."""
-    arg_gpus = getattr(args, 'gpus', None)
+    arg_gpus = getattr(args, "gpus", None)
     if isinstance(arg_gpus, int):
         return arg_gpus
     return torch.cuda.device_count()
@@ -56,17 +57,15 @@ def get_num_gpus(args):
 
 class ClassificationBenchmark(pl.LightningModule):
     """Represents an image classification benchmark model."""
-    def __init__(self, dataset, pretrained = False):
+
+    def __init__(self, dataset, pretrained=False):
         # Initialize the module.
         super(ClassificationBenchmark, self).__init__()
 
         # Construct the network.
         self._source = agml.data.source(dataset)
         self._pretrained = pretrained
-        self.net = EfficientNetB4Transfer(
-            self._source.num_classes,
-            self._pretrained
-        )
+        self.net = EfficientNetB4Transfer(self._source.num_classes, self._pretrained)
 
         # Construct the loss for training.
         self.loss = nn.CrossEntropyLoss()
@@ -74,36 +73,29 @@ def __init__(self, dataset, pretrained = False):
     def forward(self, x):
         return self.net.forward(x)
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x)
         loss = self.loss(y_pred, y)
         acc = accuracy(y_pred, torch.argmax(y, 1)).item()
-        self.log('accuracy', acc, prog_bar = True, sync_dist = True)
-        return {
-            'loss': loss,
-            'accuracy': acc
-        }
+        self.log("accuracy", acc, prog_bar=True, sync_dist=True)
+        return {"loss": loss, "accuracy": acc}
 
-    def validation_step(self, batch, *args, **kwargs): # noqa
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x)
         val_loss = self.loss(y_pred, y)
         val_acc = accuracy(y_pred, torch.argmax(y, 1))
-        self.log('val_loss', val_loss.item(), prog_bar = True, sync_dist = True)
-        self.log('val_accuracy', val_acc.item(), prog_bar = True, sync_dist = True)
-        return {
-            'val_loss': val_loss,
-            'val_accuracy': val_acc
-        }
+        self.log("val_loss", val_loss.item(), prog_bar=True, sync_dist=True)
+        self.log("val_accuracy", val_acc.item(), prog_bar=True, sync_dist=True)
+        return {"val_loss": val_loss, "val_accuracy": val_acc}
 
     def configure_optimizers(self):
         return torch.optim.Adam(self.parameters())
 
     def get_progress_bar_dict(self):
-        tqdm_dict = super(ClassificationBenchmark, self) \
-            .get_progress_bar_dict()
-        tqdm_dict.pop('v_num', None)
+        tqdm_dict = super(ClassificationBenchmark, self).get_progress_bar_dict()
+        tqdm_dict.pop("v_num", None)
         return tqdm_dict
 
 
@@ -114,20 +106,20 @@ def accuracy(output, target):
         _, pred = torch.topk(output, 1, 1)
         pred = pred.t()
         correct = pred.eq(target.view(1, -1).expand_as(pred))
-        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim = True)
+        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim=True)
         return correct_k.mul_(100.0 / batch_size)
 
 
 # Build the data loaders.
 def build_loaders(name):
     loader = agml.data.AgMLDataLoader(name)
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
-    loader.batch(batch_size = 16)
-    loader.resize_images('imagenet')
-    loader.normalize_images('imagenet')
+    loader.split(train=0.8, val=0.1, test=0.1)
+    loader.batch(batch_size=16)
+    loader.resize_images("imagenet")
+    loader.normalize_images("imagenet")
     loader.labels_to_one_hot()
     train_data = loader.train_data
-    train_data.transform(transform = A.RandomRotate90())
+    train_data.transform(transform=A.RandomRotate90())
     train_ds = train_data.copy().as_torch_dataset()
     val_ds = loader.val_data.as_torch_dataset()
     val_ds.shuffle_data = False
@@ -136,69 +128,74 @@ def build_loaders(name):
 
 
 # Main training loop method.
-def train(dataset, pretrained, epochs, gpus, save_dir = None):
+def train(dataset, pretrained, epochs, gpus, save_dir=None):
     """Constructs the training loop and trains a model."""
     if save_dir is None:
         save_dir = os.path.join(f"/data2/amnjoshi/checkpoints/{dataset}")
-        os.makedirs(save_dir, exist_ok = True)
+        os.makedirs(save_dir, exist_ok=True)
 
     # Set up the checkpoint saving callback.
     callbacks = [
         pl.callbacks.ModelCheckpoint(
-            dirpath = save_dir, mode = 'min',
-            filename = f"{dataset}" + "-epoch{epoch:02d}-val_loss_{val_loss:.2f}",
-            monitor = 'val_loss',
-            save_top_k = 3,
-            auto_insert_metric_name = False
+            dirpath=save_dir,
+            mode="min",
+            filename=f"{dataset}" + "-epoch{epoch:02d}-val_loss_{val_loss:.2f}",
+            monitor="val_loss",
+            save_top_k=3,
+            auto_insert_metric_name=False,
         ),
         pl.callbacks.EarlyStopping(
-            monitor = 'val_loss',
-            min_delta = 0.001,
-            patience = 3,
-        )
+            monitor="val_loss",
+            min_delta=0.001,
+            patience=3,
+        ),
     ]
 
     # Construct the model.
-    model = ClassificationBenchmark(
-        dataset = dataset, pretrained = pretrained)
+    model = ClassificationBenchmark(dataset=dataset, pretrained=pretrained)
 
     # Construct the data loaders.
     train_ds, val_ds, test_ds = build_loaders(dataset)
 
     # Create the trainer and train the model.
     trainer = pl.Trainer(
-        max_epochs = epochs,
-        gpus = get_num_gpus(gpus),
-        callbacks = callbacks)
-    trainer.fit(
-        model = model,
-        train_dataloaders = train_ds,
-        val_dataloaders = val_ds
+        max_epochs=epochs, gpus=get_num_gpus(gpus), callbacks=callbacks
     )
+    trainer.fit(model=model, train_dataloaders=train_ds, val_dataloaders=val_ds)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, help = "The name of the dataset.")
-    ap.add_argument(
-        '--not-pretrained', action = 'store_false',
-        default = True, help = "Whether to load a pretrained model.")
+        "--not-pretrained",
+        action="store_false",
+        default=True,
+        help="Whether to load a pretrained model.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 50,
-        help = "How many epochs to train for. Default is 50.")
+        "--epochs",
+        type=int,
+        default=50,
+        help="How many epochs to train for. Default is 50.",
+    )
     ap.add_argument(
-        '--gpus', type = int, default = None,
-        help = "How many GPUs to use when training.")
+        "--gpus", type=int, default=None, help="How many GPUs to use when training."
+    )
     args = ap.parse_args()
 
     # Train the model.
-    train(args.dataset,
-          args.not_pretrained,
-          epochs = args.epochs,
-          gpus = args.gpus,
-          save_dir = args.checkpoint_dir)
+    train(
+        args.dataset,
+        args.not_pretrained,
+        epochs=args.epochs,
+        gpus=args.gpus,
+        save_dir=args.checkpoint_dir,
+    )
diff --git a/experiments/benchmarking/classification_lightning.py b/experiments/benchmarking/classification_lightning.py
index ccc0d22c..ec5a5e88 100644
--- a/experiments/benchmarking/classification_lightning.py
+++ b/experiments/benchmarking/classification_lightning.py
@@ -12,21 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import os
 
+import albumentations as A
+import pytorch_lightning as pl
 import torch
 import torch.nn as nn
-import pytorch_lightning as pl
 from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger
-from torchmetrics.classification import Precision, Recall, Accuracy
-
+from tools import MetricLogger, checkpoint_dir, gpus
+from torchmetrics.classification import Accuracy, Precision, Recall
 from torchvision.models import efficientnet_b4
 
 import agml
-import albumentations as A
-
-from tools import gpus, checkpoint_dir, MetricLogger
 
 
 class EfficientNetB4Transfer(nn.Module):
@@ -35,15 +33,16 @@ class EfficientNetB4Transfer(nn.Module):
     This is the base benchmarking model for image classification, using
     the EfficientNetB4 model with two added linear fully-connected layers.
     """
-    def __init__(self, num_classes, pretrained = True):
+
+    def __init__(self, num_classes, pretrained=True):
         super(EfficientNetB4Transfer, self).__init__()
-        self.base = efficientnet_b4(pretrained = pretrained)
+        self.base = efficientnet_b4(pretrained=pretrained)
         self.l1 = nn.Linear(1000, 256)
         self.dropout = nn.Dropout(0.1)
         self.relu = nn.ReLU()
         self.l2 = nn.Linear(256, num_classes)
 
-    def forward(self, x, **kwargs): # noqa
+    def forward(self, x, **kwargs):  # noqa
         x = self.base(x)
         x = x.view(x.size(0), -1)
         x = self.dropout(self.relu(self.l1(x)))
@@ -53,77 +52,71 @@ def forward(self, x, **kwargs): # noqa
 
 class ClassificationBenchmark(pl.LightningModule):
     """Represents an image classification benchmark model."""
-    def __init__(self, dataset, pretrained = False, save_dir = None):
+
+    def __init__(self, dataset, pretrained=False, save_dir=None):
         # Initialize the module.
         super(ClassificationBenchmark, self).__init__()
 
         # Construct the network.
         self._source = agml.data.source(dataset)
         self._pretrained = pretrained
-        self.net = EfficientNetB4Transfer(
-            self._source.num_classes,
-            self._pretrained
-        )
+        self.net = EfficientNetB4Transfer(self._source.num_classes, self._pretrained)
 
         # Construct the loss for training.
         self.loss = nn.CrossEntropyLoss()
 
         # Add a metric calculator.
         if save_dir is not None:
-            self.metric_logger = ClassificationMetricLogger({
-                'accuracy': Accuracy(num_classes = self._source.num_classes),
-                'precision': Precision(num_classes = self._source.num_classes),
-                'recall': Recall(num_classes = self._source.num_classes)},
-                os.path.join(save_dir, f'logs-{self._version}.csv'))
+            self.metric_logger = ClassificationMetricLogger(
+                {
+                    "accuracy": Accuracy(num_classes=self._source.num_classes),
+                    "precision": Precision(num_classes=self._source.num_classes),
+                    "recall": Recall(num_classes=self._source.num_classes),
+                },
+                os.path.join(save_dir, f"logs-{self._version}.csv"),
+            )
         self._sanity_check_passed = False
 
     def forward(self, x):
         return self.net.forward(x)
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x)
         loss = self.loss(y_pred, y)
         acc = accuracy(y_pred, torch.argmax(y, 1)).item()
-        self.log('accuracy', acc, prog_bar = True, logger = True)
-        self.log('loss', loss, logger = True)
-        return {
-            'loss': loss,
-            'accuracy': acc
-        }
-
-    def validation_step(self, batch, *args, **kwargs): # noqa
+        self.log("accuracy", acc, prog_bar=True, logger=True)
+        self.log("loss", loss, logger=True)
+        return {"loss": loss, "accuracy": acc}
+
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x)
         val_loss = self.loss(y_pred, y)
         val_acc = accuracy(y_pred, torch.argmax(y, 1))
-        if self._sanity_check_passed and hasattr(self, 'metric_logger'):
+        if self._sanity_check_passed and hasattr(self, "metric_logger"):
             self.metric_logger.update(y_pred, torch.argmax(y, 1))
-        self.log('val_loss', val_loss.item(), prog_bar = True, logger = True)
-        self.log('val_accuracy', val_acc.item(), prog_bar = True, logger = True)
-        return {
-            'val_loss': val_loss,
-            'val_accuracy': val_acc
-        }
+        self.log("val_loss", val_loss.item(), prog_bar=True, logger=True)
+        self.log("val_accuracy", val_acc.item(), prog_bar=True, logger=True)
+        return {"val_loss": val_loss, "val_accuracy": val_acc}
 
     def configure_optimizers(self):
         return torch.optim.Adam(self.parameters())
 
     def get_progress_bar_dict(self):
-        tqdm_dict = super(ClassificationBenchmark, self)\
-            .get_progress_bar_dict()
-        tqdm_dict.pop('v_num', None)
+        tqdm_dict = super(ClassificationBenchmark, self).get_progress_bar_dict()
+        tqdm_dict.pop("v_num", None)
         return tqdm_dict
 
     def on_validation_epoch_end(self) -> None:
         if not self._sanity_check_passed:
             self._sanity_check_passed = True
             return
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.compile_epoch()
 
     def on_fit_end(self) -> None:
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.save()
 
 
@@ -141,7 +134,7 @@ def accuracy(output, target):
         _, pred = torch.topk(output, 1, 1)
         pred = pred.t()
         correct = pred.eq(target.view(1, -1).expand_as(pred))
-        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim = True)
+        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim=True)
         return correct_k.mul_(100.0 / batch_size)
 
 
@@ -149,13 +142,13 @@ def accuracy(output, target):
 def build_loaders(name):
     pl.seed_everything(2499751)
     loader = agml.data.AgMLDataLoader(name)
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
-    loader.batch(batch_size = 16)
-    loader.resize_images('imagenet')
-    loader.normalize_images('imagenet')
+    loader.split(train=0.8, val=0.1, test=0.1)
+    loader.batch(batch_size=16)
+    loader.resize_images("imagenet")
+    loader.normalize_images("imagenet")
     loader.labels_to_one_hot()
     train_data = loader.train_data
-    train_data.transform(transform = A.RandomRotate90())
+    train_data.transform(transform=A.RandomRotate90())
     train_ds = train_data.copy().as_torch_dataset()
     val_ds = loader.val_data.as_torch_dataset()
     val_ds.shuffle_data = False
@@ -163,100 +156,114 @@ def build_loaders(name):
     return train_ds, val_ds, test_ds
 
 
-def train(dataset, pretrained, epochs, save_dir = None, overwrite = None):
+def train(dataset, pretrained, epochs, save_dir=None, overwrite=None):
     """Constructs the training loop and trains a model."""
     save_dir = checkpoint_dir(save_dir, dataset)
-    log_dir = save_dir.replace('checkpoints', 'logs')
+    log_dir = save_dir.replace("checkpoints", "logs")
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Set up the checkpoint saving callback.
     callbacks = [
         pl.callbacks.ModelCheckpoint(
-            dirpath = save_dir, mode = 'min',
-            filename = f"{dataset}" + "-epoch{epoch:02d}-val_accuracy_{val_accuracy:.2f}",
-            monitor = 'val_accuracy',
-            save_top_k = 2,
-            auto_insert_metric_name = False
+            dirpath=save_dir,
+            mode="min",
+            filename=f"{dataset}" + "-epoch{epoch:02d}-val_accuracy_{val_accuracy:.2f}",
+            monitor="val_accuracy",
+            save_top_k=2,
+            auto_insert_metric_name=False,
         ),
     ]
 
     # Construct the model.
     model = ClassificationBenchmark(
-        dataset = dataset, pretrained = pretrained, save_dir = save_dir)
+        dataset=dataset, pretrained=pretrained, save_dir=save_dir
+    )
 
     # Construct the data loaders.
     train_ds, val_ds, test_ds = build_loaders(dataset)
 
     # Create the loggers.
-    loggers = [
-        CSVLogger(log_dir),
-        TensorBoardLogger(log_dir)
-    ]
+    loggers = [CSVLogger(log_dir), TensorBoardLogger(log_dir)]
 
     # Create the trainer and train the model.
     msg = f"Training dataset {dataset}!"
     print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
     trainer = pl.Trainer(
-        max_epochs = epochs, gpus = gpus(None),
-        callbacks = callbacks, logger = loggers,
-        log_every_n_steps = 5)
+        max_epochs=epochs,
+        gpus=gpus(None),
+        callbacks=callbacks,
+        logger=loggers,
+        log_every_n_steps=5,
+    )
     trainer.fit(
-        model = model,
-        train_dataloaders = train_ds,
-        val_dataloaders = val_ds,
+        model=model,
+        train_dataloaders=train_ds,
+        val_dataloaders=val_ds,
     )
 
     # Save the final state.
-    torch.save(model.state_dict(), os.path.join(save_dir, 'final_model.pth'))
+    torch.save(model.state_dict(), os.path.join(save_dir, "final_model.pth"))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--regenerate-existing', action = 'store_true',
-        default = False, help = "Whether to re-generate existing benchmarks.")
+        "--regenerate-existing",
+        action="store_true",
+        default=False,
+        help="Whether to re-generate existing benchmarks.",
+    )
     ap.add_argument(
-        '--not-pretrained', action = 'store_false',
-        default = True, help = "Whether to load a pretrained model.")
+        "--not-pretrained",
+        action="store_false",
+        default=True,
+        help="Whether to load a pretrained model.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 20,
-        help = "How many epochs to train for. Default is 20.")
+        "--epochs",
+        type=int,
+        default=20,
+        help="How many epochs to train for. Default is 20.",
+    )
     args = ap.parse_args()
 
     # Train the model.
-    if args.dataset[0] in agml.data.public_data_sources(ml_task = 'image_classification'):
-        train(args.dataset,
-              args.not_pretrained,
-              epochs = args.epochs,
-              save_dir = args.checkpoint_dir)
+    if args.dataset[0] in agml.data.public_data_sources(ml_task="image_classification"):
+        train(
+            args.dataset,
+            args.not_pretrained,
+            epochs=args.epochs,
+            save_dir=args.checkpoint_dir,
+        )
     else:
-        if args.dataset[0] == 'all':
-            datasets = [ds for ds in agml.data.public_data_sources(
-                ml_task = 'image_classification')]
+        if args.dataset[0] == "all":
+            datasets = [
+                ds
+                for ds in agml.data.public_data_sources(ml_task="image_classification")
+            ]
         else:
             datasets = args.dataset
         for dataset in datasets:
-            train(dataset,
-                  args.not_pretrained,
-                  epochs = args.epochs,
-                  save_dir = args.checkpoint_dir,
-                  overwrite = args.regenerate_existing)
-
-
-
-
-
-
-
+            train(
+                dataset,
+                args.not_pretrained,
+                epochs=args.epochs,
+                save_dir=args.checkpoint_dir,
+                overwrite=args.regenerate_existing,
+            )
diff --git a/experiments/benchmarking/classification_lightning_resnet50.py b/experiments/benchmarking/classification_lightning_resnet50.py
index dfd29054..e55b75b1 100644
--- a/experiments/benchmarking/classification_lightning_resnet50.py
+++ b/experiments/benchmarking/classification_lightning_resnet50.py
@@ -12,21 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import os
 
+import albumentations as A
+import pytorch_lightning as pl
 import torch
 import torch.nn as nn
-import pytorch_lightning as pl
 from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger
-from torchmetrics.classification import Precision, Recall, Accuracy
-
+from tools import MetricLogger, checkpoint_dir, gpus
+from torchmetrics.classification import Accuracy, Precision, Recall
 from torchvision.models import resnet50
 
 import agml
-import albumentations as A
-
-from tools import gpus, checkpoint_dir, MetricLogger
 
 
 class ResNet50Transfer(nn.Module):
@@ -35,15 +33,16 @@ class ResNet50Transfer(nn.Module):
     This is the base benchmarking model for image classification, using
     the ResNet50 model with two added linear fully-connected layers.
     """
-    def __init__(self, num_classes, pretrained = True):
+
+    def __init__(self, num_classes, pretrained=True):
         super(ResNet50Transfer, self).__init__()
-        self.base = resnet50(pretrained = pretrained)
+        self.base = resnet50(pretrained=pretrained)
         self.l1 = nn.Linear(1000, 256)
         self.dropout = nn.Dropout(0.1)
         self.relu = nn.ReLU()
         self.l2 = nn.Linear(256, num_classes)
 
-    def forward(self, x, **kwargs): # noqa
+    def forward(self, x, **kwargs):  # noqa
         x = self.base(x)
         x = x.view(x.size(0), -1)
         x = self.dropout(self.relu(self.l1(x)))
@@ -53,65 +52,59 @@ def forward(self, x, **kwargs): # noqa
 
 class ClassificationBenchmark(pl.LightningModule):
     """Represents an image classification benchmark model."""
-    def __init__(self, dataset, pretrained = False, save_dir = None):
+
+    def __init__(self, dataset, pretrained=False, save_dir=None):
         # Initialize the module.
         super(ClassificationBenchmark, self).__init__()
 
         # Construct the network.
         self._source = agml.data.source(dataset)
         self._pretrained = pretrained
-        self.net = ResNet50Transfer(
-            self._source.num_classes,
-            self._pretrained
-        )
+        self.net = ResNet50Transfer(self._source.num_classes, self._pretrained)
 
         # Construct the loss for training.
         self.loss = nn.CrossEntropyLoss()
 
         # Add a metric calculator.
-        self.metric_logger = ClassificationMetricLogger({
-            'accuracy': Accuracy(num_classes = self._source.num_classes),
-            'precision': Precision(num_classes = self._source.num_classes),
-            'recall': Recall(num_classes = self._source.num_classes)},
-            os.path.join(save_dir, f'logs-{self._version}.csv'))
+        self.metric_logger = ClassificationMetricLogger(
+            {
+                "accuracy": Accuracy(num_classes=self._source.num_classes),
+                "precision": Precision(num_classes=self._source.num_classes),
+                "recall": Recall(num_classes=self._source.num_classes),
+            },
+            os.path.join(save_dir, f"logs-{self._version}.csv"),
+        )
         self._sanity_check_passed = False
 
     def forward(self, x):
         return self.net.forward(x)
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x)
         loss = self.loss(y_pred, y)
         acc = accuracy(y_pred, torch.argmax(y, 1)).item()
-        self.log('accuracy', acc, prog_bar = True, logger = True)
-        self.log('loss', loss, logger = True)
-        return {
-            'loss': loss,
-            'accuracy': acc
-        }
-
-    def validation_step(self, batch, *args, **kwargs): # noqa
+        self.log("accuracy", acc, prog_bar=True, logger=True)
+        self.log("loss", loss, logger=True)
+        return {"loss": loss, "accuracy": acc}
+
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x)
         val_loss = self.loss(y_pred, y)
         val_acc = accuracy(y_pred, torch.argmax(y, 1))
         if self._sanity_check_passed:
             self.metric_logger.update(y_pred, torch.argmax(y, 1))
-        self.log('val_loss', val_loss.item(), prog_bar = True, logger = True)
-        self.log('val_accuracy', val_acc.item(), prog_bar = True, logger = True)
-        return {
-            'val_loss': val_loss,
-            'val_accuracy': val_acc
-        }
+        self.log("val_loss", val_loss.item(), prog_bar=True, logger=True)
+        self.log("val_accuracy", val_acc.item(), prog_bar=True, logger=True)
+        return {"val_loss": val_loss, "val_accuracy": val_acc}
 
     def configure_optimizers(self):
         return torch.optim.Adam(self.parameters())
 
     def get_progress_bar_dict(self):
-        tqdm_dict = super(ClassificationBenchmark, self)\
-            .get_progress_bar_dict()
-        tqdm_dict.pop('v_num', None)
+        tqdm_dict = super(ClassificationBenchmark, self).get_progress_bar_dict()
+        tqdm_dict.pop("v_num", None)
         return tqdm_dict
 
     def on_validation_epoch_end(self) -> None:
@@ -138,7 +131,7 @@ def accuracy(output, target):
         _, pred = torch.topk(output, 1, 1)
         pred = pred.t()
         correct = pred.eq(target.view(1, -1).expand_as(pred))
-        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim = True)
+        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim=True)
         return correct_k.mul_(100.0 / batch_size)
 
 
@@ -146,13 +139,13 @@ def accuracy(output, target):
 def build_loaders(name):
     pl.seed_everything(2499751)
     loader = agml.data.AgMLDataLoader(name)
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
-    loader.batch(batch_size = 16)
-    loader.resize_images('imagenet')
-    loader.normalize_images('imagenet')
+    loader.split(train=0.8, val=0.1, test=0.1)
+    loader.batch(batch_size=16)
+    loader.resize_images("imagenet")
+    loader.normalize_images("imagenet")
     loader.labels_to_one_hot()
     train_data = loader.train_data
-    train_data.transform(transform = A.RandomRotate90())
+    train_data.transform(transform=A.RandomRotate90())
     train_ds = train_data.copy().as_torch_dataset()
     val_ds = loader.val_data.as_torch_dataset()
     val_ds.shuffle_data = False
@@ -160,104 +153,118 @@ def build_loaders(name):
     return train_ds, val_ds, test_ds
 
 
-def train(dataset, pretrained, epochs, save_dir = None, overwrite = None):
+def train(dataset, pretrained, epochs, save_dir=None, overwrite=None):
     """Constructs the training loop and trains a model."""
     save_dir = "/data2/amnjoshi/resnet50_pretrained/checkpoints"
-    os.makedirs(save_dir, exist_ok = True)
-    log_dir = save_dir.replace('checkpoints', 'logs')
-    os.makedirs(log_dir, exist_ok = True)
+    os.makedirs(save_dir, exist_ok=True)
+    log_dir = save_dir.replace("checkpoints", "logs")
+    os.makedirs(log_dir, exist_ok=True)
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Set up the checkpoint saving callback.
     callbacks = [
         pl.callbacks.ModelCheckpoint(
-            dirpath = save_dir, mode = 'min',
-            filename = f"{dataset}" + "-epoch{epoch:02d}-val_loss_{val_loss:.2f}",
-            monitor = 'val_loss',
-            save_top_k = 3,
-            auto_insert_metric_name = False
+            dirpath=save_dir,
+            mode="min",
+            filename=f"{dataset}" + "-epoch{epoch:02d}-val_loss_{val_loss:.2f}",
+            monitor="val_loss",
+            save_top_k=3,
+            auto_insert_metric_name=False,
         ),
         pl.callbacks.EarlyStopping(
-            monitor = 'val_loss',
-            min_delta = 0.0001,
-            patience = 10,
-        )
+            monitor="val_loss",
+            min_delta=0.0001,
+            patience=10,
+        ),
     ]
 
     # Construct the model.
     model = ClassificationBenchmark(
-        dataset = dataset, pretrained = pretrained, save_dir = save_dir)
+        dataset=dataset, pretrained=pretrained, save_dir=save_dir
+    )
 
     # Construct the data loaders.
     train_ds, val_ds, test_ds = build_loaders(dataset)
 
     # Create the loggers.
-    loggers = [
-        CSVLogger(log_dir),
-        TensorBoardLogger(log_dir)
-    ]
+    loggers = [CSVLogger(log_dir), TensorBoardLogger(log_dir)]
 
     # Create the trainer and train the model.
     msg = f"Training dataset {dataset}!"
     print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
     trainer = pl.Trainer(
-        max_epochs = epochs, gpus = gpus(None),
-        callbacks = callbacks, logger = loggers,
-        log_every_n_steps = 5)
+        max_epochs=epochs,
+        gpus=gpus(None),
+        callbacks=callbacks,
+        logger=loggers,
+        log_every_n_steps=5,
+    )
     trainer.fit(
-        model = model,
-        train_dataloaders = train_ds,
-        val_dataloaders = val_ds,
+        model=model,
+        train_dataloaders=train_ds,
+        val_dataloaders=val_ds,
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--regenerate-existing', action = 'store_true',
-        default = False, help = "Whether to re-generate existing benchmarks.")
+        "--regenerate-existing",
+        action="store_true",
+        default=False,
+        help="Whether to re-generate existing benchmarks.",
+    )
     ap.add_argument(
-        '--not-pretrained', action = 'store_false',
-        default = True, help = "Whether to load a pretrained model.")
+        "--not-pretrained",
+        action="store_false",
+        default=True,
+        help="Whether to load a pretrained model.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 20,
-        help = "How many epochs to train for. Default is 20.")
+        "--epochs",
+        type=int,
+        default=20,
+        help="How many epochs to train for. Default is 20.",
+    )
     args = ap.parse_args()
 
     # Train the model.
-    if args.dataset[0] in agml.data.public_data_sources(ml_task = 'image_classification'):
-        train(args.dataset,
-              args.not_pretrained,
-              epochs = args.epochs,
-              save_dir = args.checkpoint_dir)
+    if args.dataset[0] in agml.data.public_data_sources(ml_task="image_classification"):
+        train(
+            args.dataset,
+            args.not_pretrained,
+            epochs=args.epochs,
+            save_dir=args.checkpoint_dir,
+        )
     else:
-        if args.dataset[0] == 'all':
-            datasets = [ds for ds in agml.data.public_data_sources(
-                ml_task = 'image_classification')]
+        if args.dataset[0] == "all":
+            datasets = [
+                ds
+                for ds in agml.data.public_data_sources(ml_task="image_classification")
+            ]
         else:
             datasets = args.dataset
         for dataset in datasets:
-            train(dataset,
-                  args.not_pretrained,
-                  epochs = args.epochs,
-                  save_dir = args.checkpoint_dir,
-                  overwrite = args.regenerate_existing)
-
-
-
-
-
-
-
+            train(
+                dataset,
+                args.not_pretrained,
+                epochs=args.epochs,
+                save_dir=args.checkpoint_dir,
+                overwrite=args.regenerate_existing,
+            )
diff --git a/experiments/benchmarking/detection_data.py b/experiments/benchmarking/detection_data.py
index 3441ee5e..d116f8b2 100644
--- a/experiments/benchmarking/detection_data.py
+++ b/experiments/benchmarking/detection_data.py
@@ -12,17 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, Union, Any
+from typing import Any, List, Union
 
+import albumentations as A
 import numpy as np
+import pytorch_lightning as pl
+import torch
 from PIL import Image
-
-import albumentations as A
 from albumentations.pytorch import ToTensorV2
-
-import torch
-from torch.utils.data import Dataset, DataLoader
-import pytorch_lightning as pl
+from torch.utils.data import DataLoader, Dataset
 
 import agml
 
@@ -36,26 +34,24 @@ def _pre_prepare_for_efficientdet(image, annotation):
     image = image.astype(np.uint8)
 
     # Clip the bounding boxes to the image shape to prevent errors.
-    bboxes = np.array(annotation['bbox']).astype(np.int32)
+    bboxes = np.array(annotation["bbox"]).astype(np.int32)
     x_min = bboxes[:, 0]
     y_min = bboxes[:, 1]
     x_max = bboxes[:, 2] + x_min
     y_max = bboxes[:, 3] + y_min
-    x_min, y_min = np.clip(x_min, 0, image.shape[1]), \
-                   np.clip(y_min, 0, image.shape[0])
-    x_max, y_max = np.clip(x_max, 0, image.shape[1]), \
-                   np.clip(y_max, 0, image.shape[0])
+    x_min, y_min = np.clip(x_min, 0, image.shape[1]), np.clip(y_min, 0, image.shape[0])
+    x_max, y_max = np.clip(x_max, 0, image.shape[1]), np.clip(y_max, 0, image.shape[0])
 
     # Reconstruct the boxes and get the class labels.
-    bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis = 0)
-    class_labels = np.array(annotation['category_id']).squeeze()
+    bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis=0)
+    class_labels = np.array(annotation["category_id"]).squeeze()
 
     # Add an extra dimension to labels for consistency.
     if class_labels.ndim == 0:
-        class_labels = np.expand_dims(class_labels, axis = 0)
+        class_labels = np.expand_dims(class_labels, axis=0)
 
     # Construct and return the sample.
-    return image, {'bboxes': bboxes, 'labels': class_labels}
+    return image, {"bboxes": bboxes, "labels": class_labels}
 
 
 def _post_prepare_for_efficientdet(image, annotation):
@@ -63,8 +59,8 @@ def _post_prepare_for_efficientdet(image, annotation):
 
     This preparation stage occurs *post-transformation*.
     """
-    bboxes = np.array(annotation['bboxes'])
-    labels = annotation['labels']
+    bboxes = np.array(annotation["bboxes"])
+    labels = annotation["labels"]
 
     # Convert 1-channel and 4-channel to 3-channel.
     if image.shape[0] == 1:
@@ -78,20 +74,18 @@ def _post_prepare_for_efficientdet(image, annotation):
 
     # Create the target from the annotations.
     target = {
-        "bboxes": torch.as_tensor(
-            bboxes, dtype = torch.float32),
+        "bboxes": torch.as_tensor(bboxes, dtype=torch.float32),
         "labels": torch.as_tensor(labels),
         "img_size": torch.tensor([new_h, new_w]),
-        "img_scale": torch.tensor([1.0])}
+        "img_scale": torch.tensor([1.0]),
+    }
     return image, target
 
 
 class TransformApplier(object):
     """Applies transforms to the data."""
 
-    def __init__(self,
-                 augmentations: Any,
-                 image_size: int = 512):
+    def __init__(self, augmentations: Any, image_size: int = 512):
         self._image_size = image_size
         if augmentations is None:
             augmentations = self._default_augmentation
@@ -100,52 +94,72 @@ def __init__(self,
     def _default_augmentation(self, image, bboxes, labels):
         # Construct the sample.
         sample = {
-            "image": np.array(image, dtype = np.float32),
+            "image": np.array(image, dtype=np.float32),
             "bboxes": bboxes,
-            "labels": labels}
+            "labels": labels,
+        }
 
         # Augment the sample.
         sample = A.Compose(
-            [A.Resize(height = self._image_size, width = self._image_size, p = 1),
-             ToTensorV2(p = 1)], p = 1.0,
-            bbox_params = A.BboxParams(
-                format = "pascal_voc", min_area = 0,
-                min_visibility = 0, label_fields = ["labels"]))(**sample)
+            [
+                A.Resize(height=self._image_size, width=self._image_size, p=1),
+                ToTensorV2(p=1),
+            ],
+            p=1.0,
+            bbox_params=A.BboxParams(
+                format="pascal_voc",
+                min_area=0,
+                min_visibility=0,
+                label_fields=["labels"],
+            ),
+        )(**sample)
 
         # Return the sample.
-        return sample['image'], {'bboxes': sample['bboxes'],
-                                 'labels': sample['labels']}
+        return sample["image"], {"bboxes": sample["bboxes"], "labels": sample["labels"]}
 
     @staticmethod
     def _unpack_result(result):
         if isinstance(result, dict):
-            return result['image'], {'bboxes': result['bboxes'], 'labels': result['labels']}
+            return result["image"], {
+                "bboxes": result["bboxes"],
+                "labels": result["labels"],
+            }
         return result
 
     def _apply_train(self, image, annotation):
         image, annotation = _pre_prepare_for_efficientdet(image, annotation)
-        image, annotation = self._unpack_result(self._augmentations['train'](
-            image = image, bboxes = annotation['bboxes'], labels = annotation['labels']))
+        image, annotation = self._unpack_result(
+            self._augmentations["train"](
+                image=image, bboxes=annotation["bboxes"], labels=annotation["labels"]
+            )
+        )
         image, annotation = _post_prepare_for_efficientdet(image, annotation)
         return image, annotation
 
     def _apply_val(self, image, annotation):
         image, annotation = _pre_prepare_for_efficientdet(image, annotation)
-        image, annotation = self._unpack_result(self._augmentations['val'](
-            image = image, bboxes = annotation['bboxes'], labels = annotation['labels']))
+        image, annotation = self._unpack_result(
+            self._augmentations["val"](
+                image=image, bboxes=annotation["bboxes"], labels=annotation["labels"]
+            )
+        )
         image, annotation = _post_prepare_for_efficientdet(image, annotation)
         return image, annotation
 
     def _apply(self, image, annotation):
         image, annotation = _pre_prepare_for_efficientdet(image, annotation)
-        image, annotation = self._unpack_result(self._augmentations(
-            image = image, bboxes = annotation['bboxes'], labels = annotation['labels']))  # noqa
+        image, annotation = self._unpack_result(
+            self._augmentations(
+                image=image, bboxes=annotation["bboxes"], labels=annotation["labels"]
+            )
+        )  # noqa
         image, annotation = _post_prepare_for_efficientdet(image, annotation)
         return image, annotation
 
 
-def build_loader(dataset: Union[List[str], str],
-                 batch_size: int = 4) -> agml.data.AgMLDataLoader:
+def build_loader(
+    dataset: Union[List[str], str], batch_size: int = 4
+) -> agml.data.AgMLDataLoader:
     """Constructs an `AgMLDataLoader` for object detection.
 
     Given either a single dataset or a list of datasets, this method will
@@ -158,10 +172,10 @@ def build_loader(dataset: Union[List[str], str],
     loader.shuffle()
 
     # Apply the batch size.
-    loader.batch(batch_size = batch_size)
+    loader.batch(batch_size=batch_size)
 
     # Split and return the loader.
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
+    loader.split(train=0.8, val=0.1, test=0.1)
     return loader
 
 
@@ -169,15 +183,17 @@ class EfficientDetDataModule(pl.LightningDataModule):
     """Wraps an `AgMLDataLoader` into a `LightningDataModule`."""
 
     def __new__(cls, *args, **kwargs):
-        if kwargs.get('no_agml', False):
+        if kwargs.get("no_agml", False):
             return EfficientDetDataModuleNoAgML(**kwargs)
         return super(EfficientDetDataModule, cls).__new__(cls, *args, **kwargs)
 
-    def __init__(self,
-                 loader: agml.data.AgMLDataLoader,
-                 augmentation: Any = None,
-                 num_workers: int = 8,
-                 **kwargs):
+    def __init__(
+        self,
+        loader: agml.data.AgMLDataLoader,
+        augmentation: Any = None,
+        num_workers: int = 8,
+        **kwargs,
+    ):
         # Get the training and validation `AgMLDataLoader`s.
         self._train_loader = loader.train_data
         self._train_loader.as_torch_dataset()
@@ -189,12 +205,9 @@ def __init__(self,
             self._train_transform = augmentation._apply_train
             self._val_transform = augmentation._apply_val
         else:
-            self._train_transform = self._val_transform = \
-                augmentation._apply
-        self._train_loader.transform(
-            dual_transform = self._train_transform)
-        self._val_loader.transform(
-            dual_transform = self._val_transform)
+            self._train_transform = self._val_transform = augmentation._apply
+        self._train_loader.transform(dual_transform=self._train_transform)
+        self._val_loader.transform(dual_transform=self._val_transform)
 
         # Initialize the base module.
         self._num_workers = num_workers
@@ -209,11 +222,11 @@ def train_dataset(self) -> Dataset:
 
     def train_dataloader(self) -> DataLoader:
         return self.train_dataset().export_torch(
-            shuffle = True,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self._num_workers,
-            collate_fn = self.collate_fn,
+            shuffle=True,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self._num_workers,
+            collate_fn=self.collate_fn,
         )
 
     @property
@@ -225,10 +238,10 @@ def val_dataset(self) -> Dataset:
 
     def val_dataloader(self) -> DataLoader:
         return self.val_dataset().export_torch(
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self._num_workers,
-            collate_fn = self.collate_fn,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self._num_workers,
+            collate_fn=self.collate_fn,
         )
 
     @staticmethod
@@ -244,20 +257,22 @@ def collate_fn(batch):
         img_scale = torch.stack([target["img_scale"] for target in targets]).float()
 
         annotations = {
-            "bbox": boxes, "cls": labels,
-            "img_size": img_size, "img_scale": img_scale}
+            "bbox": boxes,
+            "cls": labels,
+            "img_size": img_size,
+            "img_scale": img_scale,
+        }
         return images, annotations, targets
 
 
 class EfficientDetDataModuleNoAgML(pl.LightningDataModule):
     """Wraps a non-AgMLDataLoader dataset."""
 
-    def __init__(self,
-                 **kwargs):
+    def __init__(self, **kwargs):
         # A custom loader is passed.
-        self._train_ds = kwargs['train_loader']
-        self._val_ds = kwargs['val_loader']
-        self._num_workers = kwargs['num_workers']
+        self._train_ds = kwargs["train_loader"]
+        self._val_ds = kwargs["val_loader"]
+        self._num_workers = kwargs["num_workers"]
         super(EfficientDetDataModuleNoAgML, self).__init__()
 
     def train_dataset(self) -> Dataset:
@@ -266,12 +281,12 @@ def train_dataset(self) -> Dataset:
     def train_dataloader(self) -> DataLoader:
         return DataLoader(
             self.train_dataset(),
-            batch_size = 2,
-            shuffle = True,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self._num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=2,
+            shuffle=True,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self._num_workers,
+            collate_fn=self.collate_fn,
         )
 
     def val_dataset(self) -> Dataset:
@@ -280,19 +295,21 @@ def val_dataset(self) -> Dataset:
     def val_dataloader(self) -> DataLoader:
         return DataLoader(
             self.val_dataset(),
-            batch_size = 2,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self._num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=2,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self._num_workers,
+            collate_fn=self.collate_fn,
         )
 
     @staticmethod
     def collate_fn(batch):
         """Collates items together into a batch."""
         images, targets = tuple(zip(*batch))
-        images = [torch.tensor(image) if not isinstance(
-            image, torch.Tensor) else image for image in images]
+        images = [
+            torch.tensor(image) if not isinstance(image, torch.Tensor) else image
+            for image in images
+        ]
         images = torch.stack([image for image in images])
         images = images.float()
 
@@ -302,8 +319,9 @@ def collate_fn(batch):
         img_scale = torch.stack([target["img_scale"] for target in targets]).float()
 
         annotations = {
-            "bbox": boxes, "cls": labels,
-            "img_size": img_size, "img_scale": img_scale}
+            "bbox": boxes,
+            "cls": labels,
+            "img_size": img_size,
+            "img_scale": img_scale,
+        }
         return images, annotations, targets
-
-
diff --git a/experiments/benchmarking/detection_experiment.py b/experiments/benchmarking/detection_experiment.py
index f6b82ccb..ddabf613 100644
--- a/experiments/benchmarking/detection_experiment.py
+++ b/experiments/benchmarking/detection_experiment.py
@@ -16,24 +16,34 @@
 
 from experiments.benchmarking.experiment import DetectionExperiment
 
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     ap = argparse.ArgumentParser()
-    ap.add_argument('--name', help = 'The name of the experiment.', required = True)
-    ap.add_argument('--experiment_dir', help = "The name of the experiment directory.",
-                    required = False, default = None)
-    ap.add_argument('--dataset', nargs = '+', help = "Datasets to use.")
-    ap.add_argument('--batch_size', type = int, default = 4, help = "Batch size.")
-    ap.add_argument('--epochs', type = int, default = 25, help = "Number of epochs.")
-    ap.add_argument('--generalize-detections', action = 'store_true', default = False,
-                    help = "Whether to generalize all model detections to one class.")
-    ap.add_argument('--num_workers', type = int, default = 8,
-                    help = "Number of workers for DataLoaders.")
-    ap.add_argument('--pretrained_weights', type = str, default = None,
-                    help = "Either the pretrained weights or `coco`.")
+    ap.add_argument("--name", help="The name of the experiment.", required=True)
+    ap.add_argument(
+        "--experiment_dir",
+        help="The name of the experiment directory.",
+        required=False,
+        default=None,
+    )
+    ap.add_argument("--dataset", nargs="+", help="Datasets to use.")
+    ap.add_argument("--batch_size", type=int, default=4, help="Batch size.")
+    ap.add_argument("--epochs", type=int, default=25, help="Number of epochs.")
+    ap.add_argument(
+        "--generalize-detections",
+        action="store_true",
+        default=False,
+        help="Whether to generalize all model detections to one class.",
+    )
+    ap.add_argument(
+        "--num_workers", type=int, default=8, help="Number of workers for DataLoaders."
+    )
+    ap.add_argument(
+        "--pretrained_weights",
+        type=str,
+        default=None,
+        help="Either the pretrained weights or `coco`.",
+    )
     args = vars(ap.parse_args())
-    
+
     exp = DetectionExperiment(args)
     exp.train()
-
-
diff --git a/experiments/benchmarking/detection_learning.py b/experiments/benchmarking/detection_learning.py
index 631c7efc..6a0d72ae 100644
--- a/experiments/benchmarking/detection_learning.py
+++ b/experiments/benchmarking/detection_learning.py
@@ -14,57 +14,63 @@
 
 from typing import List, Union
 
+import albumentations as A
 import numpy as np
-from PIL import Image
-
-import torch
-from torch.utils.data import Dataset, DataLoader
 import pytorch_lightning as pl
-from mean_average_precision_torch import MeanAveragePrecision as MAP
-
-import albumentations as A
+import torch
+from PIL import Image
 from albumentations.pytorch import ToTensorV2
-
-from effdet import get_efficientdet_config, DetBenchTrain, create_model_from_config
+from effdet import DetBenchTrain, create_model_from_config, get_efficientdet_config
 from effdet.efficientdet import HeadNet
-
 from ensemble_boxes import ensemble_boxes_wbf
-
+from mean_average_precision_torch import MeanAveragePrecision as MAP
 from tools import auto_move_data
-
+from torch.utils.data import DataLoader, Dataset
 
 # Constants
 IMAGE_SIZE = 512
 
 
-def get_transforms(mode = 'inference'):
+def get_transforms(mode="inference"):
     """Returns a set of transforms corresponding to the mode."""
-    if mode == 'train':
+    if mode == "train":
         return A.Compose(
-            [A.HorizontalFlip(p = 0.5),
-             A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0,
-            bbox_params = A.BboxParams(
-                format = "pascal_voc", min_area = 0,
-                min_visibility = 0, label_fields = ["labels"]))
-
-    elif mode in ['val', 'validation']:
+            [
+                A.HorizontalFlip(p=0.5),
+                A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1),
+                ToTensorV2(p=1),
+            ],
+            p=1.0,
+            bbox_params=A.BboxParams(
+                format="pascal_voc",
+                min_area=0,
+                min_visibility=0,
+                label_fields=["labels"],
+            ),
+        )
+
+    elif mode in ["val", "validation"]:
         return A.Compose(
-            [A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0,
-            bbox_params = A.BboxParams(
-                format = "pascal_voc", min_area = 0,
-                min_visibility = 0, label_fields = ["labels"]))
+            [A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1), ToTensorV2(p=1)],
+            p=1.0,
+            bbox_params=A.BboxParams(
+                format="pascal_voc",
+                min_area=0,
+                min_visibility=0,
+                label_fields=["labels"],
+            ),
+        )
 
-    elif mode == 'inference':
+    elif mode == "inference":
         return A.Compose(
-            [A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0)
+            [A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1), ToTensorV2(p=1)], p=1.0
+        )
 
 
 class AgMLDatasetAdaptor(object):
     """Adapts an AgML dataset for use in a `LightningDataModule`."""
-    def __init__(self, loader, adapt_class = False):
+
+    def __init__(self, loader, adapt_class=False):
         self.loader = loader
         self.adapt_class = adapt_class
 
@@ -74,46 +80,49 @@ def __len__(self) -> int:
     def get_image_and_labels_by_idx(self, index):
         image, annotation = self.loader[index]
         image = Image.fromarray(image)
-        bboxes = np.array(annotation['bbox']).astype(np.int32)
+        bboxes = np.array(annotation["bbox"]).astype(np.int32)
         x_min = bboxes[:, 0]
         y_min = bboxes[:, 1]
         x_max = bboxes[:, 2] + x_min
         y_max = bboxes[:, 3] + y_min
         x_min, y_min = np.clip(x_min, 0, image.width), np.clip(y_min, 0, image.height)
         x_max, y_max = np.clip(x_max, 0, image.width), np.clip(y_max, 0, image.height)
-        bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis = 0)
-        class_labels = np.array(annotation['category_id']).squeeze()
+        bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis=0)
+        class_labels = np.array(annotation["category_id"]).squeeze()
         if self.adapt_class:
             class_labels = np.ones_like(class_labels)
         return image, bboxes, class_labels, index
 
 
 class EfficientDetDataset(Dataset):
-    def __init__(self, adaptor, transforms = None):
+    def __init__(self, adaptor, transforms=None):
         self.ds = adaptor
         if transforms is None:
-            transforms = get_transforms('val')
+            transforms = get_transforms("val")
         self.transforms = transforms
 
     def __len__(self):
         return len(self.ds)
 
     def __getitem__(self, index):
-        image, pascal_bboxes, class_labels, image_id = \
+        image, pascal_bboxes, class_labels, image_id = (
             self.ds.get_image_and_labels_by_idx(index)
+        )
 
         # Add a label dimension for consistency.
         if class_labels.ndim == 0:
-            class_labels = np.expand_dims(class_labels, axis = 0)
+            class_labels = np.expand_dims(class_labels, axis=0)
 
         # Construct the sample.
         sample = {
-            "image": np.array(image, dtype = np.float32),
-            "bboxes": pascal_bboxes, "labels": class_labels}
+            "image": np.array(image, dtype=np.float32),
+            "bboxes": pascal_bboxes,
+            "labels": class_labels,
+        }
 
         try:
             sample = self.transforms(**sample)
-        except: # debugging
+        except:  # debugging
             raise Exception(f"Failed sample: {sample}")
 
         sample["bboxes"] = np.array(sample["bboxes"])
@@ -128,87 +137,85 @@ def __getitem__(self, index):
 
         # Convert to yxyx from xyxy.
         _, new_h, new_w = image.shape
-        sample["bboxes"][:, [0, 1, 2, 3]] = \
-            sample["bboxes"][:, [1, 0, 3, 2]]
+        sample["bboxes"][:, [0, 1, 2, 3]] = sample["bboxes"][:, [1, 0, 3, 2]]
 
         # Create the target from the annotations.
         target = {
-            "bboxes": torch.as_tensor(sample["bboxes"], dtype = torch.float32),
-            "labels": torch.as_tensor(labels), "image_id": torch.tensor([image_id]),
-            "img_size": (new_h, new_w), "img_scale": torch.tensor([1.0])}
+            "bboxes": torch.as_tensor(sample["bboxes"], dtype=torch.float32),
+            "labels": torch.as_tensor(labels),
+            "image_id": torch.tensor([image_id]),
+            "img_size": (new_h, new_w),
+            "img_scale": torch.tensor([1.0]),
+        }
         return image, target, image_id
 
 
 class EfficientDetDataModule(pl.LightningDataModule):
     """A `LightningDataModule` for the `LightningModule`."""
 
-    def __init__(self,
-                 train_dataset_adaptor,
-                 validation_dataset_adaptor,
-                 test_dataset_adaptor = None,
-                 train_transforms = None,
-                 val_transforms = None,
-                 num_workers = 4,
-                 batch_size = 8):
+    def __init__(
+        self,
+        train_dataset_adaptor,
+        validation_dataset_adaptor,
+        test_dataset_adaptor=None,
+        train_transforms=None,
+        val_transforms=None,
+        num_workers=4,
+        batch_size=8,
+    ):
         self.train_ds = train_dataset_adaptor
         self.valid_ds = validation_dataset_adaptor
         if test_dataset_adaptor is not None:
             self.test_ds = test_dataset_adaptor
         if train_transforms is None:
-            train_transforms = get_transforms('train')
+            train_transforms = get_transforms("train")
         self.train_tfms = train_transforms
         if val_transforms is None:
-            val_transforms = get_transforms('val')
+            val_transforms = get_transforms("val")
         self.val_tfms = val_transforms
         self.num_workers = num_workers
         self.batch_size = batch_size
         super().__init__()
 
     def train_dataset(self) -> EfficientDetDataset:
-        return EfficientDetDataset(
-            adaptor = self.train_ds,
-            transforms = self.train_tfms)
+        return EfficientDetDataset(adaptor=self.train_ds, transforms=self.train_tfms)
 
     def train_dataloader(self) -> DataLoader:
         return DataLoader(
             self.train_dataset(),
-            batch_size = self.batch_size,
-            shuffle = True,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self.num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=self.batch_size,
+            shuffle=True,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self.num_workers,
+            collate_fn=self.collate_fn,
         )
 
     def val_dataset(self) -> EfficientDetDataset:
-        return EfficientDetDataset(
-            adaptor = self.valid_ds,
-            transforms = self.val_tfms)
+        return EfficientDetDataset(adaptor=self.valid_ds, transforms=self.val_tfms)
 
     def val_dataloader(self) -> DataLoader:
         return DataLoader(
             self.val_dataset(),
-            batch_size = self.batch_size,
-            shuffle = False,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self.num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=self.batch_size,
+            shuffle=False,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self.num_workers,
+            collate_fn=self.collate_fn,
         )
 
     def test_dataset(self) -> EfficientDetDataset:
-        return EfficientDetDataset(
-            adaptor = self.test_ds,
-            transforms = self.val_tfms)
+        return EfficientDetDataset(adaptor=self.test_ds, transforms=self.val_tfms)
 
     def test_dataloader(self) -> DataLoader:
         return DataLoader(
             self.test_dataset(),
-            batch_size = self.batch_size,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self.num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=self.batch_size,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self.num_workers,
+            collate_fn=self.collate_fn,
         )
 
     @staticmethod
@@ -223,45 +230,49 @@ def collate_fn(batch):
         img_scale = torch.tensor([target["img_scale"] for target in targets]).float()
 
         annotations = {
-            "bbox": boxes, "cls": labels,
-            "img_size": img_size, "img_scale": img_scale}
+            "bbox": boxes,
+            "cls": labels,
+            "img_size": img_size,
+            "img_scale": img_scale,
+        }
         return images, annotations, targets, image_ids
 
 
 class EfficientDetModel(pl.LightningModule):
-    def __init__(self,
-                 num_classes = 1,
-                 confidence_threshold = 0.3,
-                 learning_rate = 0.0002,
-                 wbf_iou_threshold = 0.44,
-                 inference_transforms = None,
-                 architecture = 'efficientdet_d4',
-                 pretrained = False,
-                 pretrained_path = None,
-                 validation_dataset_adaptor = None,
-                 test_dataset_adaptor = None):
+    def __init__(
+        self,
+        num_classes=1,
+        confidence_threshold=0.3,
+        learning_rate=0.0002,
+        wbf_iou_threshold=0.44,
+        inference_transforms=None,
+        architecture="efficientdet_d4",
+        pretrained=False,
+        pretrained_path=None,
+        validation_dataset_adaptor=None,
+        test_dataset_adaptor=None,
+    ):
         super().__init__()
         if pretrained_path is not None:
             self.model = create_model_from_pretrained(
-                num_classes, architecture = architecture,
-                pretrained_path = pretrained_path)
+                num_classes, architecture=architecture, pretrained_path=pretrained_path
+            )
         else:
             self.model = create_model(
-                num_classes, architecture = architecture,
-                pretrained = pretrained)
+                num_classes, architecture=architecture, pretrained=pretrained
+            )
         self.confidence_threshold = confidence_threshold
         self.lr = learning_rate
         self.wbf_iou_threshold = wbf_iou_threshold
         if inference_transforms is None:
-            inference_transforms = get_transforms('inference')
+            inference_transforms = get_transforms("inference")
         self.inference_tfms = inference_transforms
 
         # Construct the metric.
         self.val_dataset_adaptor = None
         if validation_dataset_adaptor is not None:
             # Add a metric calculator.
-            self.val_dataset_adaptor = AgMLDatasetAdaptor(
-                validation_dataset_adaptor)
+            self.val_dataset_adaptor = AgMLDatasetAdaptor(validation_dataset_adaptor)
             self.map = MAP()
         self.test_dataset_adaptor = AgMLDatasetAdaptor(test_dataset_adaptor)
         self.test_map = MAP()
@@ -272,7 +283,7 @@ def forward(self, images, targets):
         return self.model(images, targets)
 
     def configure_optimizers(self):
-        opt = torch.optim.AdamW(self.model.parameters(), lr = self.lr)
+        opt = torch.optim.AdamW(self.model.parameters(), lr=self.lr)
         return opt
 
     def training_step(self, batch, batch_idx):
@@ -281,13 +292,29 @@ def training_step(self, batch, batch_idx):
         losses = self.model(images, annotations)
 
         # Calculate and log losses.
-        self.log("train_loss", losses["loss"], on_step = True,
-                 on_epoch = True, prog_bar = True, logger = True)
-        self.log("train_class_loss", losses["class_loss"],
-                 on_step = True, on_epoch = True, logger = True)
-        self.log("train_box_loss", losses["box_loss"], on_step = True,
-                 on_epoch = True, logger = True)
-        return losses['loss']
+        self.log(
+            "train_loss",
+            losses["loss"],
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+        )
+        self.log(
+            "train_class_loss",
+            losses["class_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+        )
+        self.log(
+            "train_box_loss",
+            losses["box_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+        )
+        return losses["loss"]
 
     @torch.no_grad()
     def validation_step(self, batch, batch_idx):
@@ -298,19 +325,29 @@ def validation_step(self, batch, batch_idx):
         # Update the metric.
         if self.val_dataset_adaptor is not None and self._sanity_check_passed:
             for idx in image_ids:
-                image, truth_boxes, truth_cls, _ = \
+                image, truth_boxes, truth_cls, _ = (
                     self.val_dataset_adaptor.get_image_and_labels_by_idx(idx)
+                )
                 pred_box, pred_labels, pred_conf = self.predict([image])
                 if not isinstance(pred_labels[0], float):
-                    pred_box, pred_labels, pred_conf = pred_box[0], pred_labels[0], pred_conf[0]
+                    pred_box, pred_labels, pred_conf = (
+                        pred_box[0],
+                        pred_labels[0],
+                        pred_conf[0],
+                    )
                 if truth_cls.ndim == 0:
                     truth_cls = np.expand_dims(truth_cls, 0)
-                metric_update_values = \
-                    dict(boxes = torch.tensor(pred_box, dtype = torch.float32),
-                         labels = torch.tensor(pred_labels, dtype = torch.int32),
-                         scores = torch.tensor(pred_conf)), \
-                    dict(boxes = torch.tensor(truth_boxes, dtype = torch.float32),
-                         labels = torch.tensor(truth_cls, dtype = torch.int32))
+                metric_update_values = (
+                    dict(
+                        boxes=torch.tensor(pred_box, dtype=torch.float32),
+                        labels=torch.tensor(pred_labels, dtype=torch.int32),
+                        scores=torch.tensor(pred_conf),
+                    ),
+                    dict(
+                        boxes=torch.tensor(truth_boxes, dtype=torch.float32),
+                        labels=torch.tensor(truth_cls, dtype=torch.int32),
+                    ),
+                )
                 self.map.update(*metric_update_values)
 
         batch_predictions = {
@@ -324,16 +361,33 @@ def validation_step(self, batch, batch_idx):
             "box_loss": outputs["box_loss"].detach(),
         }
 
-        self.log("valid_loss", outputs["loss"], on_step = True, on_epoch = True,
-                 prog_bar = True, logger = True, sync_dist = True)
-        self.log("valid_class_loss", logging_losses["class_loss"],
-                 on_step = True, on_epoch = True,
-                 logger = True, sync_dist = True)
-        self.log("valid_box_loss", logging_losses["box_loss"],
-                 on_step = True, on_epoch = True,
-                 logger = True, sync_dist = True)
+        self.log(
+            "valid_loss",
+            outputs["loss"],
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+            sync_dist=True,
+        )
+        self.log(
+            "valid_class_loss",
+            logging_losses["class_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+            sync_dist=True,
+        )
+        self.log(
+            "valid_box_loss",
+            logging_losses["box_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+            sync_dist=True,
+        )
 
-        return {'loss': outputs["loss"], 'batch_predictions': batch_predictions}
+        return {"loss": outputs["loss"], "batch_predictions": batch_predictions}
 
     def test_step(self, batch, batch_idx):
         images, annotations, targets, image_ids = batch
@@ -343,19 +397,29 @@ def test_step(self, batch, batch_idx):
         # Calculate the mean average precision.
         if self._sanity_check_passed:
             for idx in image_ids:
-                image, truth_boxes, truth_cls, _ = \
+                image, truth_boxes, truth_cls, _ = (
                     self.test_dataset_adaptor.get_image_and_labels_by_idx(idx)
+                )
                 pred_box, pred_labels, pred_conf = self.predict([image])
                 if not isinstance(pred_labels[0], float):
-                    pred_box, pred_labels, pred_conf = pred_box[0], pred_labels[0], pred_conf[0]
+                    pred_box, pred_labels, pred_conf = (
+                        pred_box[0],
+                        pred_labels[0],
+                        pred_conf[0],
+                    )
                 if truth_cls.ndim == 0:
                     truth_cls = np.expand_dims(truth_cls, 0)
-                metric_update_values = \
-                    dict(boxes = torch.tensor(pred_box, dtype = torch.float32),
-                         labels = torch.tensor(pred_labels, dtype = torch.int32),
-                         scores = torch.tensor(pred_conf)), \
-                    dict(boxes = torch.tensor(truth_boxes, dtype = torch.float32),
-                         labels = torch.tensor(truth_cls, dtype = torch.int32))
+                metric_update_values = (
+                    dict(
+                        boxes=torch.tensor(pred_box, dtype=torch.float32),
+                        labels=torch.tensor(pred_labels, dtype=torch.int32),
+                        scores=torch.tensor(pred_conf),
+                    ),
+                    dict(
+                        boxes=torch.tensor(truth_boxes, dtype=torch.float32),
+                        labels=torch.tensor(truth_cls, dtype=torch.int32),
+                    ),
+                )
                 self.map.update(*metric_update_values)
 
     def predict(self, images: Union[torch.Tensor, List]):
@@ -373,20 +437,27 @@ def predict(self, images: Union[torch.Tensor, List]):
         """
         if isinstance(images, list):
             image_sizes = [(image.size[1], image.size[0]) for image in images]
-            images_tensor = torch.stack([
-                self.inference_tfms(
-                    image = np.array(image, dtype = np.float32),
-                )["image"] for image in images])
+            images_tensor = torch.stack(
+                [
+                    self.inference_tfms(
+                        image=np.array(image, dtype=np.float32),
+                    )["image"]
+                    for image in images
+                ]
+            )
             return self._run_inference(images_tensor, image_sizes)
         elif isinstance(images, torch.Tensor):
             image_tensor = images
             if image_tensor.ndim == 3:
                 image_tensor = image_tensor.unsqueeze(0)
-            if image_tensor.shape[-1] != IMAGE_SIZE \
-                    or image_tensor.shape[-2] != IMAGE_SIZE:
+            if (
+                image_tensor.shape[-1] != IMAGE_SIZE
+                or image_tensor.shape[-2] != IMAGE_SIZE
+            ):
                 raise ValueError(
                     f"Input tensors must be of shape "
-                    f"(N, 3, {IMAGE_SIZE}, {IMAGE_SIZE})")
+                    f"(N, 3, {IMAGE_SIZE}, {IMAGE_SIZE})"
+                )
 
             num_images = image_tensor.shape[0]
             image_sizes = [(IMAGE_SIZE, IMAGE_SIZE)] * num_images
@@ -394,40 +465,50 @@ def predict(self, images: Union[torch.Tensor, List]):
         else:
             raise TypeError(
                 "Expected either a list of images or a "
-                "torch.Tensor of images for `predict()`.")
+                "torch.Tensor of images for `predict()`."
+            )
 
     def _run_inference(self, images_tensor, image_sizes):
         dummy_targets = self._create_dummy_inference_targets(
-            images_tensor.shape[0], self.device, IMAGE_SIZE)
+            images_tensor.shape[0], self.device, IMAGE_SIZE
+        )
 
-        detections = self.model(
-            images_tensor.to(self.device), dummy_targets)["detections"]
+        detections = self.model(images_tensor.to(self.device), dummy_targets)[
+            "detections"
+        ]
 
-        predicted_bboxes, predicted_class_confidences, predicted_class_labels = \
+        predicted_bboxes, predicted_class_confidences, predicted_class_labels = (
             self.post_process_detections(detections)
+        )
         scaled_bboxes = self._rescale_bboxes(
-            predicted_bboxes = predicted_bboxes,
-            image_sizes = image_sizes)
+            predicted_bboxes=predicted_bboxes, image_sizes=image_sizes
+        )
         return scaled_bboxes, predicted_class_labels, predicted_class_confidences
 
     @staticmethod
     def _create_dummy_inference_targets(num_images, device, size):
         return {
             "bbox": [
-                torch.tensor([[0.0, 0.0, 0.0, 0.0]], device = device)
+                torch.tensor([[0.0, 0.0, 0.0, 0.0]], device=device)
                 for _ in range(num_images)
             ],
-            "cls": [torch.tensor([1.0], device = device) for _ in range(num_images)],
+            "cls": [torch.tensor([1.0], device=device) for _ in range(num_images)],
             "img_size": torch.tensor(
-                [(size, size)] * num_images, device = device).float(),
-            "img_scale": torch.ones(num_images, device = device).float(),
+                [(size, size)] * num_images, device=device
+            ).float(),
+            "img_scale": torch.ones(num_images, device=device).float(),
         }
 
     def post_process_detections(self, detections):
-        predictions = [self._postprocess_single_prediction_detections(d) for d in detections]
-
-        predicted_bboxes, predicted_class_confidences, predicted_class_labels = self.run_wbf(
-            predictions, image_size = IMAGE_SIZE, iou_thr = self.wbf_iou_threshold)
+        predictions = [
+            self._postprocess_single_prediction_detections(d) for d in detections
+        ]
+
+        predicted_bboxes, predicted_class_confidences, predicted_class_labels = (
+            self.run_wbf(
+                predictions, image_size=IMAGE_SIZE, iou_thr=self.wbf_iou_threshold
+            )
+        )
         return predicted_bboxes, predicted_class_confidences, predicted_class_labels
 
     def _postprocess_single_prediction_detections(self, detections):
@@ -451,16 +532,24 @@ def _rescale_bboxes(predicted_bboxes, image_sizes):
             im_h, im_w = img_dims
             if len(bboxes) > 0:
                 scaled_bboxes.append(
-                    (np.array(bboxes) * [
-                        im_w / IMAGE_SIZE, im_h / IMAGE_SIZE,
-                        im_w / IMAGE_SIZE, im_h / IMAGE_SIZE
-                    ]).tolist())
+                    (
+                        np.array(bboxes)
+                        * [
+                            im_w / IMAGE_SIZE,
+                            im_h / IMAGE_SIZE,
+                            im_w / IMAGE_SIZE,
+                            im_h / IMAGE_SIZE,
+                        ]
+                    ).tolist()
+                )
             else:
                 scaled_bboxes.append(bboxes)
         return scaled_bboxes
 
     @staticmethod
-    def run_wbf(predictions, image_size = 512, iou_thr = 0.44, skip_box_thr = 0.43, weights = None):
+    def run_wbf(
+        predictions, image_size=512, iou_thr=0.44, skip_box_thr=0.43, weights=None
+    ):
         bboxes, confidences, class_labels = [], [], []
 
         for prediction in predictions:
@@ -469,8 +558,13 @@ def run_wbf(predictions, image_size = 512, iou_thr = 0.44, skip_box_thr = 0.43,
             labels = [prediction["classes"].tolist()]
 
             boxes, scores, labels = ensemble_boxes_wbf.weighted_boxes_fusion(
-                boxes, scores, labels, weights = weights,
-                iou_thr = iou_thr, skip_box_thr = skip_box_thr)
+                boxes,
+                scores,
+                labels,
+                weights=weights,
+                iou_thr=iou_thr,
+                skip_box_thr=skip_box_thr,
+            )
             boxes = boxes * (image_size - 1)
             bboxes.append(boxes.tolist())
             confidences.append(scores.tolist())
@@ -480,37 +574,39 @@ def run_wbf(predictions, image_size = 512, iou_thr = 0.44, skip_box_thr = 0.43,
 
     def on_test_epoch_end(self):
         map = self.test_map.compute().detach().cpu().numpy().item()
-        self.log("test-map", map, prog_bar = True,
-                 on_epoch = True,
-                 logger = True, sync_dist = True)
+        self.log(
+            "test-map", map, prog_bar=True, on_epoch=True, logger=True, sync_dist=True
+        )
         self.test_map.reset()
 
     def on_validation_epoch_end(self) -> None:
         if not self._sanity_check_passed:
             self._sanity_check_passed = True
             return
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.compile_epoch()
-        if hasattr(self, 'map'):
+        if hasattr(self, "map"):
             map = self.map.compute().detach().cpu().numpy().item()
-            self.log("map", map, prog_bar = True,
-                     on_epoch = True,
-                     logger = True, sync_dist = True)
+            self.log(
+                "map", map, prog_bar=True, on_epoch=True, logger=True, sync_dist=True
+            )
             self.map.reset()
 
     def on_fit_end(self) -> None:
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.save()
-        if hasattr(self, 'map'):
+        if hasattr(self, "map"):
             self.map.reset()
 
     def get_progress_bar_dict(self):
         p_bar = super(EfficientDetModel, self).get_progress_bar_dict()
-        p_bar.pop('v_num', None)
+        p_bar.pop("v_num", None)
         return p_bar
 
 
-def create_model(num_classes = 1, architecture = "tf_efficientdet_d4", pretrained = (False, False)):
+def create_model(
+    num_classes=1, architecture="tf_efficientdet_d4", pretrained=(False, False)
+):
     if isinstance(pretrained, bool):
         if pretrained is False:
             pretrained = True
@@ -520,30 +616,29 @@ def create_model(num_classes = 1, architecture = "tf_efficientdet_d4", pretraine
     if isinstance(pretrained, str):
         return create_model_from_pretrained(num_classes, architecture, pretrained)
     config = get_efficientdet_config(architecture)
-    config.update({'image_size': (IMAGE_SIZE, IMAGE_SIZE)})
+    config.update({"image_size": (IMAGE_SIZE, IMAGE_SIZE)})
 
-    net = create_model_from_config(config, pretrained = pretrained, num_classes = num_classes)
+    net = create_model_from_config(
+        config, pretrained=pretrained, num_classes=num_classes
+    )
     net.class_net = HeadNet(
         config,
-        num_outputs = num_classes,
+        num_outputs=num_classes,
     )
     return DetBenchTrain(net, config)
 
 
 # Modification of the above to load pretrained weights from a path.
 def create_model_from_pretrained(
-        num_classes = 1,
-        architecture = "tf_efficientdet_d4",
-        pretrained_path = None):
+    num_classes=1, architecture="tf_efficientdet_d4", pretrained_path=None
+):
     config = get_efficientdet_config(architecture)
-    config.update({'image_size': (IMAGE_SIZE, IMAGE_SIZE)})
+    config.update({"image_size": (IMAGE_SIZE, IMAGE_SIZE)})
 
     net = create_model_from_config(
-        config, num_classes = pretrained_path[1], pretrained = False)
-    net.load_state_dict(
-        torch.load(pretrained_path[0], map_location = 'cpu'))
+        config, num_classes=pretrained_path[1], pretrained=False
+    )
+    net.load_state_dict(torch.load(pretrained_path[0], map_location="cpu"))
     if net.config.num_classes != num_classes:
-        net.reset_head(num_classes = num_classes)
+        net.reset_head(num_classes=num_classes)
     return DetBenchTrain(net, config)
-
-
diff --git a/experiments/benchmarking/detection_lightning.py b/experiments/benchmarking/detection_lightning.py
index 8c9f02b5..32c459af 100644
--- a/experiments/benchmarking/detection_lightning.py
+++ b/experiments/benchmarking/detection_lightning.py
@@ -19,88 +19,90 @@
 2. https://gist.github.com/Chris-hughes10/73628b1d8d6fc7d359b3dcbbbb8869d7
 """
 
-import os
 import argparse
+import os
 
-import torch
 import pytorch_lightning as pl
-from pytorch_lightning.loggers import WandbLogger
+import torch
+from detection_learning import AgMLDatasetAdaptor, EfficientDetDataModule, EfficientDetModel
 from pytorch_lightning.callbacks import LearningRateMonitor
+from pytorch_lightning.loggers import WandbLogger
+from tools import checkpoint_dir, gpus
 
 import agml
-from tools import gpus, checkpoint_dir
-from detection_learning import (
-    AgMLDatasetAdaptor, EfficientDetDataModule, EfficientDetModel
-)
 
 
-def train(dataset, epochs, save_dir = None,
-          overwrite = None, pretrained_path = None):
+def train(dataset, epochs, save_dir=None, overwrite=None, pretrained_path=None):
     """Constructs the training loop and trains a model."""
     save_dir = os.path.dirname(checkpoint_dir(save_dir, dataset))
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Set up the checkpoint saving callback.
     callbacks = [
         pl.callbacks.ModelCheckpoint(
-            dirpath = save_dir, mode = 'min',
-            filename = f"{dataset}" + "-epoch{epoch:02d}-valid_loss_{valid_loss:.2f}",
-            monitor = 'valid_loss',
-            save_top_k = 3,
-            auto_insert_metric_name = False
+            dirpath=save_dir,
+            mode="min",
+            filename=f"{dataset}" + "-epoch{epoch:02d}-valid_loss_{valid_loss:.2f}",
+            monitor="valid_loss",
+            save_top_k=3,
+            auto_insert_metric_name=False,
         )
     ]
 
     # Create the loggers.
     loggers = [
-        WandbLogger(project = 'detection-experiments', name = args.name,
-                    save_dir = save_dir)
+        WandbLogger(project="detection-experiments", name=args.name, save_dir=save_dir)
     ]
 
     # Construct the data.
     pl.seed_everything(2499751)
     loader = agml.data.AgMLDataLoader(dataset)
     loader.shuffle()
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
+    loader.split(train=0.8, val=0.1, test=0.1)
     dm = EfficientDetDataModule(
-        train_dataset_adaptor = AgMLDatasetAdaptor(loader.train_data),
-        validation_dataset_adaptor = AgMLDatasetAdaptor(loader.val_data),
-        num_workers = 12, batch_size = 4)
+        train_dataset_adaptor=AgMLDatasetAdaptor(loader.train_data),
+        validation_dataset_adaptor=AgMLDatasetAdaptor(loader.val_data),
+        num_workers=12,
+        batch_size=4,
+    )
 
     # Construct the model.
     model = EfficientDetModel(
-        num_classes = loader.num_classes,
-        architecture = 'tf_efficientdet_d4',
-        pretrained = pretrained_path,
-        validation_dataset_adaptor = loader.val_data)
+        num_classes=loader.num_classes,
+        architecture="tf_efficientdet_d4",
+        pretrained=pretrained_path,
+        validation_dataset_adaptor=loader.val_data,
+    )
 
     # Create the trainer and train the model.
     msg = f"Training dataset {dataset}!"
     print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
-    trainer = pl.Trainer(
-        max_epochs = epochs, gpus = gpus(None),
-        logger = loggers)
+    trainer = pl.Trainer(max_epochs=epochs, gpus=gpus(None), logger=loggers)
     trainer.fit(model, dm)
 
     # Save the final state.
-    torch.save(model.state_dict(), os.path.join(save_dir, 'final_model.pth'))
+    torch.save(model.state_dict(), os.path.join(save_dir, "final_model.pth"))
 
 
-def train_per_class(dataset, epochs, save_dir = None, overwrite = None):
+def train_per_class(dataset, epochs, save_dir=None, overwrite=None):
     """Constructs the training loop and trains a model."""
     save_dir = checkpoint_dir(save_dir, dataset)
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Construct the loader.
@@ -113,34 +115,40 @@ def train_per_class(dataset, epochs, save_dir = None, overwrite = None):
         # Create the data module with the new, reduced class.
         cls = cl + 1
         new_loader = loader.take_class(cls)
-        new_loader.split(train = 0.8, val = 0.1, test = 0.1)
+        new_loader.split(train=0.8, val=0.1, test=0.1)
         dm = EfficientDetDataModule(
-            train_dataset_adaptor = AgMLDatasetAdaptor(
-                new_loader.train_data, adapt_class = True),
-            validation_dataset_adaptor = AgMLDatasetAdaptor(
-                new_loader.val_data, adapt_class = True),
-            test_dataset_adaptor = AgMLDatasetAdaptor(
-                new_loader.test_data, adapt_class = True),
-            num_workers = 12, batch_size = 4)
-
-        name = f'{loader.num_to_class[cls]}-{cls}' + f'-{args.name}'
+            train_dataset_adaptor=AgMLDatasetAdaptor(
+                new_loader.train_data, adapt_class=True
+            ),
+            validation_dataset_adaptor=AgMLDatasetAdaptor(
+                new_loader.val_data, adapt_class=True
+            ),
+            test_dataset_adaptor=AgMLDatasetAdaptor(
+                new_loader.test_data, adapt_class=True
+            ),
+            num_workers=12,
+            batch_size=4,
+        )
+
+        name = f"{loader.num_to_class[cls]}-{cls}" + f"-{args.name}"
         this_save_dir = os.path.join(save_dir, name)
-        os.makedirs(this_save_dir, exist_ok = True)
+        os.makedirs(this_save_dir, exist_ok=True)
 
         # Create the loggers.
         loggers = [
-            WandbLogger(project = 'detection-experiments',
-                        save_dir = this_save_dir,
-                        name = name)
+            WandbLogger(
+                project="detection-experiments", save_dir=this_save_dir, name=name
+            )
         ]
 
         # Construct the model.
         model = EfficientDetModel(
-            num_classes = 1,
-            architecture = 'tf_efficientdet_d4',
-            pretrained = True,
-            validation_dataset_adaptor = new_loader.val_data,
-            test_dataset_adaptor = new_loader.test_data)
+            num_classes=1,
+            architecture="tf_efficientdet_d4",
+            pretrained=True,
+            validation_dataset_adaptor=new_loader.val_data,
+            test_dataset_adaptor=new_loader.test_data,
+        )
         # model.load_state_dict(
         #     torch.load('/data2/amnjoshi/detection-models/amg.pth',
         #                map_location = 'cpu'))
@@ -149,72 +157,95 @@ def train_per_class(dataset, epochs, save_dir = None, overwrite = None):
         msg = f"Training dataset {dataset} for class {cls}: {loader.num_to_class[cls]}!"
         print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
         trainer = pl.Trainer(
-            max_epochs = epochs, gpus = gpus(None), logger = loggers,
-            callbacks = LearningRateMonitor('step'))
+            max_epochs=epochs,
+            gpus=gpus(None),
+            logger=loggers,
+            callbacks=LearningRateMonitor("step"),
+        )
         trainer.fit(model, dm)
 
         # Save the final state.
-        torch.save(model.state_dict(), os.path.join(this_save_dir, 'final_model.pth'))
+        torch.save(model.state_dict(), os.path.join(this_save_dir, "final_model.pth"))
 
         # Test the loader.
-        trainer.test(datamodule = dm)
+        trainer.test(datamodule=dm)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--name", type=str, help="The name of the run.", default=None)
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--name', type = str, help = "The name of the run.", default = None)
-    ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--regenerate-existing', action = 'store_true',
-        default = False, help = "Whether to re-generate existing benchmarks.")
+        "--regenerate-existing",
+        action="store_true",
+        default=False,
+        help="Whether to re-generate existing benchmarks.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 50,
-        help = "How many epochs to train for. Default is 50.")
+        "--epochs",
+        type=int,
+        default=50,
+        help="How many epochs to train for. Default is 50.",
+    )
     ap.add_argument(
-        '--per-class-for-dataset', action = 'store_true',
-        default = False, help = "Whether to generate benchmarks per class.")
+        "--per-class-for-dataset",
+        action="store_true",
+        default=False,
+        help="Whether to generate benchmarks per class.",
+    )
     ap.add_argument(
-        '--pretrained-model-path', type = str, default = None,
-        help = "The path to a set of pretrained weights for the model.")
+        "--pretrained-model-path",
+        type=str,
+        default=None,
+        help="The path to a set of pretrained weights for the model.",
+    )
     ap.add_argument(
-        '--pretrained-num-classes', type = str, default = None,
-        help = "The number of classes in the pretrained model.")
+        "--pretrained-num-classes",
+        type=str,
+        default=None,
+        help="The number of classes in the pretrained model.",
+    )
     args = ap.parse_args()
     if args.name is None:
         args.name = args.dataset
 
     # Train the model.
     if args.per_class_for_dataset:
-        train_per_class(args.dataset[0],
-                        epochs = args.epochs,
-                        save_dir = args.checkpoint_dir)
-    elif args.dataset[0] in agml.data.public_data_sources(ml_task = 'object_detection') \
-            and len(args.dataset) > 1:
-        train(args.dataset,
-              epochs = args.epochs,
-              save_dir = args.checkpoint_dir,
-              pretrained_path = (args.pretrained_model_path,
-                                 args.pretrained_num_classes))
+        train_per_class(
+            args.dataset[0], epochs=args.epochs, save_dir=args.checkpoint_dir
+        )
+    elif (
+        args.dataset[0] in agml.data.public_data_sources(ml_task="object_detection")
+        and len(args.dataset) > 1
+    ):
+        train(
+            args.dataset,
+            epochs=args.epochs,
+            save_dir=args.checkpoint_dir,
+            pretrained_path=(args.pretrained_model_path, args.pretrained_num_classes),
+        )
     else:
-        if args.dataset[0] == 'all':
-            datasets = [ds for ds in agml.data.public_data_sources(
-                ml_task = 'object_detection')]
+        if args.dataset[0] == "all":
+            datasets = [
+                ds for ds in agml.data.public_data_sources(ml_task="object_detection")
+            ]
         else:
             datasets = args.dataset
         for ds in datasets:
-            train(ds,
-                  epochs = args.epochs,
-                  save_dir = args.checkpoint_dir,
-                  overwrite = args.regenerate_existing,
-                  pretrained_path = (args.pretrained_model_path,
-                                     args.pretrained_num_classes))
-
-
-
-
+            train(
+                ds,
+                epochs=args.epochs,
+                save_dir=args.checkpoint_dir,
+                overwrite=args.regenerate_existing,
+                pretrained_path=(
+                    args.pretrained_model_path,
+                    args.pretrained_num_classes,
+                ),
+            )
diff --git a/experiments/benchmarking/detection_lightning_local.py b/experiments/benchmarking/detection_lightning_local.py
index 876979d1..039b0c89 100644
--- a/experiments/benchmarking/detection_lightning_local.py
+++ b/experiments/benchmarking/detection_lightning_local.py
@@ -19,35 +19,33 @@
 2. https://gist.github.com/Chris-hughes10/73628b1d8d6fc7d359b3dcbbbb8869d7
 """
 
-import os
 import argparse
+import os
 from typing import List, Union
 
+import albumentations as A
 import numpy as np
-from PIL import Image
-
-import torch
-from torch.utils.data import Dataset, DataLoader
 import pytorch_lightning as pl
-from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger
-from mean_average_precision import MeanAveragePrecision
-
-import agml
-import albumentations as A
+import torch
+from PIL import Image
 from albumentations.pytorch import ToTensorV2
-
-from agml.models.training_resources.model import get_efficientdet_config, HeadNet, create_model_from_config
-from agml.models.training_resources.bench import DetBenchTrain, DetBenchPredict
-
 from ensemble_boxes import ensemble_boxes_wbf
+from mean_average_precision import MeanAveragePrecision
+from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger
+from tools import MetricLogger, auto_move_data, checkpoint_dir, gpus
+from torch.utils.data import DataLoader, Dataset
 
-from tools import gpus, checkpoint_dir, MetricLogger, auto_move_data
+import agml
+from agml.models.training_resources.bench import DetBenchPredict, DetBenchTrain
+from agml.models.training_resources.model import HeadNet, create_model_from_config, get_efficientdet_config
 
 # Constants
 IMAGE_SIZE = 512
 
 
-def create_model(num_classes = 1, architecture = "tf_efficientdet_d4", pretrained = (False, False)):
+def create_model(
+    num_classes=1, architecture="tf_efficientdet_d4", pretrained=(False, False)
+):
     if isinstance(pretrained, bool):
         if pretrained is False:
             pretrained = True
@@ -57,37 +55,38 @@ def create_model(num_classes = 1, architecture = "tf_efficientdet_d4", pretraine
     if isinstance(pretrained, str):
         return create_model_from_pretrained(num_classes, architecture, pretrained)
     config = get_efficientdet_config(architecture)
-    config.update({'image_size': (IMAGE_SIZE, IMAGE_SIZE)})
+    config.update({"image_size": (IMAGE_SIZE, IMAGE_SIZE)})
 
-    net = create_model_from_config(config, pretrained = pretrained, num_classes = num_classes)
+    net = create_model_from_config(
+        config, pretrained=pretrained, num_classes=num_classes
+    )
     net.class_net = HeadNet(
         config,
-        num_outputs = num_classes,
+        num_outputs=num_classes,
     )
     return DetBenchTrain(net, config)
 
 
 # Modification of the above to load pretrained weights from a path.
 def create_model_from_pretrained(
-        num_classes = 1,
-        architecture = "tf_efficientdet_d4",
-        pretrained_path = None):
+    num_classes=1, architecture="tf_efficientdet_d4", pretrained_path=None
+):
     config = get_efficientdet_config(architecture)
-    config.update({'image_size': (IMAGE_SIZE, IMAGE_SIZE)})
+    config.update({"image_size": (IMAGE_SIZE, IMAGE_SIZE)})
 
     net = create_model_from_config(
-        config, num_classes = pretrained_path[1], pretrained = False)
+        config, num_classes=pretrained_path[1], pretrained=False
+    )
     if net.num_classes != num_classes:
-        net.reset_head(num_classes = num_classes)
-    net.load_state_dict(
-        torch.load(pretrained_path[0], map_location = 'cpu'))
+        net.reset_head(num_classes=num_classes)
+    net.load_state_dict(torch.load(pretrained_path[0], map_location="cpu"))
     return DetBenchTrain(net, config)
 
 
 class AgMLDatasetAdaptor(object):
     """Adapts an AgML dataset for use in a `LightningDataModule`."""
 
-    def __init__(self, loader, adapt_class = False):
+    def __init__(self, loader, adapt_class=False):
         self.loader = loader
         self.adapt_class = adapt_class
 
@@ -97,67 +96,81 @@ def __len__(self) -> int:
     def get_image_and_labels_by_idx(self, index):
         image, annotation = self.loader[index]
         image = Image.fromarray(image)
-        bboxes = np.array(annotation['bbox']).astype(np.int32)
+        bboxes = np.array(annotation["bbox"]).astype(np.int32)
         x_min = bboxes[:, 0]
         y_min = bboxes[:, 1]
         x_max = bboxes[:, 2] + x_min
         y_max = bboxes[:, 3] + y_min
         x_min, y_min = np.clip(x_min, 0, image.width), np.clip(y_min, 0, image.height)
         x_max, y_max = np.clip(x_max, 0, image.width), np.clip(y_max, 0, image.height)
-        bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis = 0)
-        class_labels = np.array(annotation['category_id']).squeeze()
+        bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis=0)
+        class_labels = np.array(annotation["category_id"]).squeeze()
         if self.adapt_class:
             class_labels = np.ones_like(class_labels)
         return image, bboxes, class_labels, index
 
 
-def get_transforms(mode = 'inference'):
+def get_transforms(mode="inference"):
     """Returns a set of transforms corresponding to the mode."""
-    if mode == 'train':
+    if mode == "train":
         return A.Compose(
-            [A.HorizontalFlip(p = 0.5),
-             A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0,
-            bbox_params = A.BboxParams(
-                format = "pascal_voc", min_area = 0,
-                min_visibility = 0, label_fields = ["labels"]))
-
-    elif mode in ['val', 'validation']:
+            [
+                A.HorizontalFlip(p=0.5),
+                A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1),
+                ToTensorV2(p=1),
+            ],
+            p=1.0,
+            bbox_params=A.BboxParams(
+                format="pascal_voc",
+                min_area=0,
+                min_visibility=0,
+                label_fields=["labels"],
+            ),
+        )
+
+    elif mode in ["val", "validation"]:
         return A.Compose(
-            [A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0,
-            bbox_params = A.BboxParams(
-                format = "pascal_voc", min_area = 0,
-                min_visibility = 0, label_fields = ["labels"]))
+            [A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1), ToTensorV2(p=1)],
+            p=1.0,
+            bbox_params=A.BboxParams(
+                format="pascal_voc",
+                min_area=0,
+                min_visibility=0,
+                label_fields=["labels"],
+            ),
+        )
 
-    elif mode == 'inference':
+    elif mode == "inference":
         return A.Compose(
-            [A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0)
+            [A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1), ToTensorV2(p=1)], p=1.0
+        )
 
 
 class EfficientDetDataset(Dataset):
-    def __init__(self, adaptor, transforms = None):
+    def __init__(self, adaptor, transforms=None):
         self.ds = adaptor
         if transforms is None:
-            transforms = get_transforms('val')
+            transforms = get_transforms("val")
         self.transforms = transforms
 
     def __len__(self):
         return len(self.ds)
 
     def __getitem__(self, index):
-        image, pascal_bboxes, class_labels, image_id = \
+        image, pascal_bboxes, class_labels, image_id = (
             self.ds.get_image_and_labels_by_idx(index)
+        )
 
         # Add a label dimension for consistency.
         if class_labels.ndim == 0:
-            class_labels = np.expand_dims(class_labels, axis = 0)
+            class_labels = np.expand_dims(class_labels, axis=0)
 
         # Construct the sample.
         sample = {
-            "image": np.array(image, dtype = np.float32),
-            "bboxes": pascal_bboxes, "labels": class_labels}
+            "image": np.array(image, dtype=np.float32),
+            "bboxes": pascal_bboxes,
+            "labels": class_labels,
+        }
 
         try:
             sample = self.transforms(**sample)
@@ -176,69 +189,69 @@ def __getitem__(self, index):
 
         # Convert to yxyx from xyxy.
         _, new_h, new_w = image.shape
-        sample["bboxes"][:, [0, 1, 2, 3]] = \
-            sample["bboxes"][:, [1, 0, 3, 2]]
+        sample["bboxes"][:, [0, 1, 2, 3]] = sample["bboxes"][:, [1, 0, 3, 2]]
 
         # Create the target from the annotations.
         target = {
-            "bboxes": torch.as_tensor(sample["bboxes"], dtype = torch.float32),
-            "labels": torch.as_tensor(labels), "image_id": torch.tensor([image_id]),
-            "img_size": (new_h, new_w), "img_scale": torch.tensor([1.0])}
+            "bboxes": torch.as_tensor(sample["bboxes"], dtype=torch.float32),
+            "labels": torch.as_tensor(labels),
+            "image_id": torch.tensor([image_id]),
+            "img_size": (new_h, new_w),
+            "img_scale": torch.tensor([1.0]),
+        }
         return image, target, image_id
 
 
 class EfficientDetDataModule(pl.LightningDataModule):
     """A `LightningDataModule` for the `LightningModule`."""
 
-    def __init__(self,
-                 train_dataset_adaptor,
-                 validation_dataset_adaptor,
-                 train_transforms = None,
-                 val_transforms = None,
-                 num_workers = 4,
-                 batch_size = 8):
+    def __init__(
+        self,
+        train_dataset_adaptor,
+        validation_dataset_adaptor,
+        train_transforms=None,
+        val_transforms=None,
+        num_workers=4,
+        batch_size=8,
+    ):
         self.train_ds = train_dataset_adaptor
         self.valid_ds = validation_dataset_adaptor
         if train_transforms is None:
-            train_transforms = get_transforms('train')
+            train_transforms = get_transforms("train")
         self.train_tfms = train_transforms
         if val_transforms is None:
-            val_transforms = get_transforms('val')
+            val_transforms = get_transforms("val")
         self.val_tfms = val_transforms
         self.num_workers = num_workers
         self.batch_size = batch_size
         super().__init__()
 
     def train_dataset(self) -> EfficientDetDataset:
-        return EfficientDetDataset(
-            adaptor = self.train_ds,
-            transforms = self.train_tfms)
+        return EfficientDetDataset(adaptor=self.train_ds, transforms=self.train_tfms)
 
     def train_dataloader(self) -> DataLoader:
         return DataLoader(
             self.train_dataset(),
-            batch_size = self.batch_size,
-            shuffle = True,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self.num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=self.batch_size,
+            shuffle=True,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self.num_workers,
+            collate_fn=self.collate_fn,
         )
 
     def val_dataset(self) -> EfficientDetDataset:
-        return EfficientDetDataset(
-            adaptor = self.valid_ds,
-            transforms = self.val_tfms)
+        return EfficientDetDataset(adaptor=self.valid_ds, transforms=self.val_tfms)
 
     def val_dataloader(self) -> DataLoader:
         return DataLoader(
             self.val_dataset(),
-            batch_size = self.batch_size,
-            shuffle = False,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self.num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=self.batch_size,
+            shuffle=False,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self.num_workers,
+            collate_fn=self.collate_fn,
         )
 
     @staticmethod
@@ -253,43 +266,48 @@ def collate_fn(batch):
         img_scale = torch.tensor([target["img_scale"] for target in targets]).float()
 
         annotations = {
-            "bbox": boxes, "cls": labels,
-            "img_size": img_size, "img_scale": img_scale}
+            "bbox": boxes,
+            "cls": labels,
+            "img_size": img_size,
+            "img_scale": img_scale,
+        }
         return images, annotations, targets, image_ids
 
 
 class EfficientDetModel(pl.LightningModule):
-    def __init__(self,
-                 num_classes = 1,
-                 confidence_threshold = 0.3,
-                 learning_rate = 0.0002,
-                 wbf_iou_threshold = 0.44,
-                 inference_transforms = None,
-                 architecture = 'efficientdet_d4',
-                 save_dir = None,
-                 pretrained = False,
-                 validation_dataset_adaptor = None):
+    def __init__(
+        self,
+        num_classes=1,
+        confidence_threshold=0.3,
+        learning_rate=0.0002,
+        wbf_iou_threshold=0.44,
+        inference_transforms=None,
+        architecture="efficientdet_d4",
+        save_dir=None,
+        pretrained=False,
+        validation_dataset_adaptor=None,
+    ):
         super().__init__()
         self.model = create_model(
-            num_classes, architecture = architecture,
-            pretrained = pretrained)
+            num_classes, architecture=architecture, pretrained=pretrained
+        )
         self.confidence_threshold = confidence_threshold
         self.lr = learning_rate
         self.wbf_iou_threshold = wbf_iou_threshold
         if inference_transforms is None:
-            inference_transforms = get_transforms('inference')
+            inference_transforms = get_transforms("inference")
         self.inference_tfms = inference_transforms
 
         # Construct the metric.
         self.val_dataset_adaptor = None
         if validation_dataset_adaptor is not None:
             # Add a metric calculator.
-            self.val_dataset_adaptor = AgMLDatasetAdaptor(
-                validation_dataset_adaptor)
+            self.val_dataset_adaptor = AgMLDatasetAdaptor(validation_dataset_adaptor)
             self.map = MeanAveragePrecision()
-            self.metric_logger = DetectionMetricLogger({
-                'map': MeanAveragePrecision()},
-                os.path.join(save_dir, f'logs-{self._version}.csv'))
+            self.metric_logger = DetectionMetricLogger(
+                {"map": MeanAveragePrecision()},
+                os.path.join(save_dir, f"logs-{self._version}.csv"),
+            )
         self._sanity_check_passed = False
 
     @auto_move_data
@@ -297,7 +315,7 @@ def forward(self, images, targets):
         return self.model(images, targets)
 
     def configure_optimizers(self):
-        return torch.optim.AdamW(self.model.parameters(), lr = self.lr)
+        return torch.optim.AdamW(self.model.parameters(), lr=self.lr)
 
     def training_step(self, batch, batch_idx):
         # Run a forward pass through the model.
@@ -305,13 +323,29 @@ def training_step(self, batch, batch_idx):
         losses = self.model(images, annotations)
 
         # Calculate and log losses.
-        self.log("train_loss", losses["loss"], on_step = True,
-                 on_epoch = True, prog_bar = True, logger = True)
-        self.log("train_class_loss", losses["class_loss"],
-                 on_step = True, on_epoch = True, logger = True)
-        self.log("train_box_loss", losses["box_loss"], on_step = True,
-                 on_epoch = True, logger = True)
-        return losses['loss']
+        self.log(
+            "train_loss",
+            losses["loss"],
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+        )
+        self.log(
+            "train_class_loss",
+            losses["class_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+        )
+        self.log(
+            "train_box_loss",
+            losses["box_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+        )
+        return losses["loss"]
 
     @torch.no_grad()
     def validation_step(self, batch, batch_idx):
@@ -321,22 +355,35 @@ def validation_step(self, batch, batch_idx):
 
         # Update the metric.
         if self.val_dataset_adaptor is not None and self._sanity_check_passed:
-            predicted_bboxes, predicted_class_confidences, predicted_class_labels = \
+            predicted_bboxes, predicted_class_confidences, predicted_class_labels = (
                 self.post_process_detections(detections)
+            )
             for idx, pred_box, pred_conf, pred_labels in zip(
-                    image_ids, predicted_bboxes,
-                    predicted_class_confidences,
-                    predicted_class_labels):
-                image, truth_boxes, truth_cls, _ = \
+                image_ids,
+                predicted_bboxes,
+                predicted_class_confidences,
+                predicted_class_labels,
+            ):
+                image, truth_boxes, truth_cls, _ = (
                     self.val_dataset_adaptor.get_image_and_labels_by_idx(idx)
-                metric_update_values = \
-                    [[pred_box, pred_labels, pred_conf], [truth_boxes, truth_cls]]
+                )
+                metric_update_values = [
+                    [pred_box, pred_labels, pred_conf],
+                    [truth_boxes, truth_cls],
+                ]
                 self.metric_logger.update_metrics(*metric_update_values)
                 self.map.update(*metric_update_values)
 
             # Compute the metric result.
-            self.log("map", self.map.compute(), on_step = True, on_epoch = True,
-                     prog_bar = True, logger = True, sync_dist = True)
+            self.log(
+                "map",
+                self.map.compute(),
+                on_step=True,
+                on_epoch=True,
+                prog_bar=True,
+                logger=True,
+                sync_dist=True,
+            )
 
         batch_predictions = {
             "predictions": detections,
@@ -349,16 +396,33 @@ def validation_step(self, batch, batch_idx):
             "box_loss": outputs["box_loss"].detach(),
         }
 
-        self.log("valid_loss", outputs["loss"], on_step = True, on_epoch = True,
-                 prog_bar = True, logger = True, sync_dist = True)
-        self.log("valid_class_loss", logging_losses["class_loss"],
-                 on_step = True, on_epoch = True,
-                 logger = True, sync_dist = True)
-        self.log("valid_box_loss", logging_losses["box_loss"],
-                 on_step = True, on_epoch = True,
-                 logger = True, sync_dist = True)
+        self.log(
+            "valid_loss",
+            outputs["loss"],
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+            sync_dist=True,
+        )
+        self.log(
+            "valid_class_loss",
+            logging_losses["class_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+            sync_dist=True,
+        )
+        self.log(
+            "valid_box_loss",
+            logging_losses["box_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+            sync_dist=True,
+        )
 
-        return {'loss': outputs["loss"], 'batch_predictions': batch_predictions}
+        return {"loss": outputs["loss"], "batch_predictions": batch_predictions}
 
     def predict(self, images: Union[torch.Tensor, List]):
         """Runs inference on a set of images.
@@ -375,20 +439,27 @@ def predict(self, images: Union[torch.Tensor, List]):
         """
         if isinstance(images, list):
             image_sizes = [(image.size[1], image.size[0]) for image in images]
-            images_tensor = torch.stack([
-                self.inference_tfms(
-                    image = np.array(image, dtype = np.float32),
-                )["image"] for image in images])
+            images_tensor = torch.stack(
+                [
+                    self.inference_tfms(
+                        image=np.array(image, dtype=np.float32),
+                    )["image"]
+                    for image in images
+                ]
+            )
             return self._run_inference(images_tensor, image_sizes)
         elif isinstance(images, torch.Tensor):
             image_tensor = images
             if image_tensor.ndim == 3:
                 image_tensor = image_tensor.unsqueeze(0)
-            if image_tensor.shape[-1] != IMAGE_SIZE \
-                    or image_tensor.shape[-2] != IMAGE_SIZE:
+            if (
+                image_tensor.shape[-1] != IMAGE_SIZE
+                or image_tensor.shape[-2] != IMAGE_SIZE
+            ):
                 raise ValueError(
                     f"Input tensors must be of shape "
-                    f"(N, 3, {IMAGE_SIZE}, {IMAGE_SIZE})")
+                    f"(N, 3, {IMAGE_SIZE}, {IMAGE_SIZE})"
+                )
 
             num_images = image_tensor.shape[0]
             image_sizes = [(IMAGE_SIZE, IMAGE_SIZE)] * num_images
@@ -396,40 +467,50 @@ def predict(self, images: Union[torch.Tensor, List]):
         else:
             raise TypeError(
                 "Expected either a list of images or a "
-                "torch.Tensor of images for `predict()`.")
+                "torch.Tensor of images for `predict()`."
+            )
 
     def _run_inference(self, images_tensor, image_sizes):
         dummy_targets = self._create_dummy_inference_targets(
-            images_tensor.shape[0], self.device, IMAGE_SIZE)
+            images_tensor.shape[0], self.device, IMAGE_SIZE
+        )
 
-        detections = self.model(
-            images_tensor.to(self.device), dummy_targets)["detections"]
+        detections = self.model(images_tensor.to(self.device), dummy_targets)[
+            "detections"
+        ]
 
-        predicted_bboxes, predicted_class_confidences, predicted_class_labels = \
+        predicted_bboxes, predicted_class_confidences, predicted_class_labels = (
             self.post_process_detections(detections)
+        )
         scaled_bboxes = self._rescale_bboxes(
-            predicted_bboxes = predicted_bboxes,
-            image_sizes = image_sizes)
+            predicted_bboxes=predicted_bboxes, image_sizes=image_sizes
+        )
         return scaled_bboxes, predicted_class_labels, predicted_class_confidences
 
     @staticmethod
     def _create_dummy_inference_targets(num_images, device, size):
         return {
             "bbox": [
-                torch.tensor([[0.0, 0.0, 0.0, 0.0]], device = device)
+                torch.tensor([[0.0, 0.0, 0.0, 0.0]], device=device)
                 for _ in range(num_images)
             ],
-            "cls": [torch.tensor([1.0], device = device) for _ in range(num_images)],
+            "cls": [torch.tensor([1.0], device=device) for _ in range(num_images)],
             "img_size": torch.tensor(
-                [(size, size)] * num_images, device = device).float(),
-            "img_scale": torch.ones(num_images, device = device).float(),
+                [(size, size)] * num_images, device=device
+            ).float(),
+            "img_scale": torch.ones(num_images, device=device).float(),
         }
 
     def post_process_detections(self, detections):
-        predictions = [self._postprocess_single_prediction_detections(d) for d in detections]
+        predictions = [
+            self._postprocess_single_prediction_detections(d) for d in detections
+        ]
 
-        predicted_bboxes, predicted_class_confidences, predicted_class_labels = self.run_wbf(
-            predictions, image_size = IMAGE_SIZE, iou_thr = self.wbf_iou_threshold)
+        predicted_bboxes, predicted_class_confidences, predicted_class_labels = (
+            self.run_wbf(
+                predictions, image_size=IMAGE_SIZE, iou_thr=self.wbf_iou_threshold
+            )
+        )
         return predicted_bboxes, predicted_class_confidences, predicted_class_labels
 
     def _postprocess_single_prediction_detections(self, detections):
@@ -453,16 +534,24 @@ def _rescale_bboxes(predicted_bboxes, image_sizes):
             im_h, im_w = img_dims
             if len(bboxes) > 0:
                 scaled_bboxes.append(
-                    (np.array(bboxes) * [
-                        im_w / IMAGE_SIZE, im_h / IMAGE_SIZE,
-                        im_w / IMAGE_SIZE, im_h / IMAGE_SIZE
-                    ]).tolist())
+                    (
+                        np.array(bboxes)
+                        * [
+                            im_w / IMAGE_SIZE,
+                            im_h / IMAGE_SIZE,
+                            im_w / IMAGE_SIZE,
+                            im_h / IMAGE_SIZE,
+                        ]
+                    ).tolist()
+                )
             else:
                 scaled_bboxes.append(bboxes)
         return scaled_bboxes
 
     @staticmethod
-    def run_wbf(predictions, image_size = 512, iou_thr = 0.44, skip_box_thr = 0.43, weights = None):
+    def run_wbf(
+        predictions, image_size=512, iou_thr=0.44, skip_box_thr=0.43, weights=None
+    ):
         bboxes, confidences, class_labels = [], [], []
 
         for prediction in predictions:
@@ -471,8 +560,13 @@ def run_wbf(predictions, image_size = 512, iou_thr = 0.44, skip_box_thr = 0.43,
             labels = [prediction["classes"].tolist()]
 
             boxes, scores, labels = ensemble_boxes_wbf.weighted_boxes_fusion(
-                boxes, scores, labels, weights = weights,
-                iou_thr = iou_thr, skip_box_thr = skip_box_thr)
+                boxes,
+                scores,
+                labels,
+                weights=weights,
+                iou_thr=iou_thr,
+                skip_box_thr=skip_box_thr,
+            )
             boxes = boxes * (image_size - 1)
             bboxes.append(boxes.tolist())
             confidences.append(scores.tolist())
@@ -484,93 +578,97 @@ def on_validation_epoch_end(self) -> None:
         if not self._sanity_check_passed:
             self._sanity_check_passed = True
             return
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.compile_epoch()
 
     def on_fit_end(self) -> None:
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.save()
 
     def get_progress_bar_dict(self):
         p_bar = super(EfficientDetModel, self).get_progress_bar_dict()
-        p_bar.pop('v_num', None)
+        p_bar.pop("v_num", None)
         return p_bar
 
 
 # Calculate and log the metrics.
 class DetectionMetricLogger(MetricLogger):
     def update_metrics(self, y_pred, y_true) -> None:
-        self.metrics['map'].update(y_pred, y_true)
+        self.metrics["map"].update(y_pred, y_true)
 
 
-def train(dataset, epochs, save_dir = None,
-          overwrite = None, pretrained_path = None):
+def train(dataset, epochs, save_dir=None, overwrite=None, pretrained_path=None):
     """Constructs the training loop and trains a model."""
     save_dir = checkpoint_dir(save_dir, dataset)
-    log_dir = save_dir.replace('checkpoints', 'logs')
+    log_dir = save_dir.replace("checkpoints", "logs")
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Set up the checkpoint saving callback.
     callbacks = [
         pl.callbacks.ModelCheckpoint(
-            dirpath = save_dir, mode = 'min',
-            filename = f"{dataset}" + "-epoch{epoch:02d}-valid_loss_{valid_loss:.2f}",
-            monitor = 'valid_loss',
-            save_top_k = 3,
-            auto_insert_metric_name = False
+            dirpath=save_dir,
+            mode="min",
+            filename=f"{dataset}" + "-epoch{epoch:02d}-valid_loss_{valid_loss:.2f}",
+            monitor="valid_loss",
+            save_top_k=3,
+            auto_insert_metric_name=False,
         )
     ]
 
     # Create the loggers.
-    loggers = [
-        CSVLogger(log_dir),
-        TensorBoardLogger(log_dir)
-    ]
+    loggers = [CSVLogger(log_dir), TensorBoardLogger(log_dir)]
 
     # Construct the data.
     pl.seed_everything(2499751)
     loader = agml.data.AgMLDataLoader(dataset)
     loader.shuffle()
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
+    loader.split(train=0.8, val=0.1, test=0.1)
     dm = EfficientDetDataModule(
-        train_dataset_adaptor = AgMLDatasetAdaptor(loader.train_data),
-        validation_dataset_adaptor = AgMLDatasetAdaptor(loader.val_data),
-        num_workers = 12, batch_size = 4)
+        train_dataset_adaptor=AgMLDatasetAdaptor(loader.train_data),
+        validation_dataset_adaptor=AgMLDatasetAdaptor(loader.val_data),
+        num_workers=12,
+        batch_size=4,
+    )
 
     # Construct the model.
     model = EfficientDetModel(
-        num_classes = loader.info.num_classes,
-        architecture = 'tf_efficientdet_d4',
-        pretrained = True)
+        num_classes=loader.info.num_classes,
+        architecture="tf_efficientdet_d4",
+        pretrained=True,
+    )
 
     # Create the trainer and train the model.
     msg = f"Training dataset {dataset}!"
     print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
     trainer = pl.Trainer(
-        max_epochs = epochs, gpus = gpus(None),
-        callbacks = callbacks, logger = loggers)
+        max_epochs=epochs, gpus=gpus(None), callbacks=callbacks, logger=loggers
+    )
     trainer.fit(model, dm)
 
     # Save the final state.
-    torch.save(model.state_dict(), os.path.join(save_dir, 'final_model.pth'))
+    torch.save(model.state_dict(), os.path.join(save_dir, "final_model.pth"))
 
 
-def train_per_class(dataset, epochs, save_dir = None, overwrite = None):
+def train_per_class(dataset, epochs, save_dir=None, overwrite=None):
     """Constructs the training loop and trains a model."""
     save_dir = checkpoint_dir(save_dir, dataset)
-    log_dir = save_dir.replace('checkpoints', 'logs')
+    log_dir = save_dir.replace("checkpoints", "logs")
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Construct the loader.
@@ -583,107 +681,131 @@ def train_per_class(dataset, epochs, save_dir = None, overwrite = None):
         # Create the data module with the new, reduced class.
         cls = cl + 1
         new_loader = loader.take_class(cls)
-        new_loader.split(train = 0.8, val = 0.1, test = 0.1)
+        new_loader.split(train=0.8, val=0.1, test=0.1)
         dm = EfficientDetDataModule(
-            train_dataset_adaptor = AgMLDatasetAdaptor(
-                new_loader.train_data, adapt_class = True),
-            validation_dataset_adaptor = AgMLDatasetAdaptor(
-                new_loader.val_data, adapt_class = True),
-            num_workers = 12, batch_size = 4)
+            train_dataset_adaptor=AgMLDatasetAdaptor(
+                new_loader.train_data, adapt_class=True
+            ),
+            validation_dataset_adaptor=AgMLDatasetAdaptor(
+                new_loader.val_data, adapt_class=True
+            ),
+            num_workers=12,
+            batch_size=4,
+        )
 
-        this_save_dir = os.path.join(
-            save_dir, f'{new_loader.num_to_class[cls]}-{cls}')
-        this_log_dir = this_save_dir.replace('checkpoints', 'logs')
+        this_save_dir = os.path.join(save_dir, f"{new_loader.num_to_class[cls]}-{cls}")
+        this_log_dir = this_save_dir.replace("checkpoints", "logs")
 
         # Set up the checkpoint saving callback.
         callbacks = [
             pl.callbacks.ModelCheckpoint(
-                dirpath = this_save_dir, mode = 'min',
-                filename = f"{dataset}" + "-epoch{epoch:02d}-valid_loss_{valid_loss:.2f}",
-                monitor = 'valid_loss',
-                save_top_k = 3,
-                auto_insert_metric_name = False
+                dirpath=this_save_dir,
+                mode="min",
+                filename=f"{dataset}" + "-epoch{epoch:02d}-valid_loss_{valid_loss:.2f}",
+                monitor="valid_loss",
+                save_top_k=3,
+                auto_insert_metric_name=False,
             )
         ]
 
         # Create the loggers.
-        loggers = [
-            CSVLogger(this_log_dir),
-            TensorBoardLogger(this_log_dir)
-        ]
+        loggers = [CSVLogger(this_log_dir), TensorBoardLogger(this_log_dir)]
 
         # Construct the model.
         model = EfficientDetModel(
-            num_classes = 1,
-            architecture = 'tf_efficientdet_d4',
-            pretrained = True)
+            num_classes=1, architecture="tf_efficientdet_d4", pretrained=True
+        )
         model.load_state_dict(
-            torch.load('/data2/amnjoshi/full_grape/checkpoints/final_model.pth',
-                       map_location = 'cpu'))
+            torch.load(
+                "/data2/amnjoshi/full_grape/checkpoints/final_model.pth",
+                map_location="cpu",
+            )
+        )
 
         # Create the trainer and train the model.
         msg = f"Training dataset {dataset} for class {cls}: {loader.num_to_class[cls]}!"
         print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
         trainer = pl.Trainer(
-            max_epochs = epochs, gpus = gpus(None),
-            callbacks = callbacks, logger = loggers)
+            max_epochs=epochs, gpus=gpus(None), callbacks=callbacks, logger=loggers
+        )
         trainer.fit(model, dm)
 
         # Save the final state.
-        torch.save(model.state_dict(), os.path.join(this_save_dir, 'final_model.pth'))
+        torch.save(model.state_dict(), os.path.join(this_save_dir, "final_model.pth"))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--regenerate-existing', action = 'store_true',
-        default = False, help = "Whether to re-generate existing benchmarks.")
+        "--regenerate-existing",
+        action="store_true",
+        default=False,
+        help="Whether to re-generate existing benchmarks.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 50,
-        help = "How many epochs to train for. Default is 50.")
+        "--epochs",
+        type=int,
+        default=50,
+        help="How many epochs to train for. Default is 50.",
+    )
     ap.add_argument(
-        '--per-class-for-dataset', action = 'store_true',
-        default = False, help = "Whether to generate benchmarks per class.")
+        "--per-class-for-dataset",
+        action="store_true",
+        default=False,
+        help="Whether to generate benchmarks per class.",
+    )
     ap.add_argument(
-        '--pretrained-model-path', type = str, default = None,
-        help = "The path to a set of pretrained weights for the model.")
+        "--pretrained-model-path",
+        type=str,
+        default=None,
+        help="The path to a set of pretrained weights for the model.",
+    )
     ap.add_argument(
-        '--pretrained-num-classes', type = str, default = None,
-        help = "The number of classes in the pretrained model..")
+        "--pretrained-num-classes",
+        type=str,
+        default=None,
+        help="The number of classes in the pretrained model..",
+    )
     args = ap.parse_args()
 
     # Train the model.
     if args.per_class_for_dataset:
-        train_per_class(args.dataset[0],
-                        epochs = args.epochs,
-                        save_dir = args.checkpoint_dir)
-    elif args.dataset[0] in agml.data.public_data_sources(ml_task = 'object_detection') \
-            and len(args.dataset) > 1:
-        train(args.dataset,
-              epochs = args.epochs,
-              save_dir = args.checkpoint_dir,
-              pretrained_path = (args.pretrained_model_path,
-                                 args.pretrained_num_classes))
+        train_per_class(
+            args.dataset[0], epochs=args.epochs, save_dir=args.checkpoint_dir
+        )
+    elif (
+        args.dataset[0] in agml.data.public_data_sources(ml_task="object_detection")
+        and len(args.dataset) > 1
+    ):
+        train(
+            args.dataset,
+            epochs=args.epochs,
+            save_dir=args.checkpoint_dir,
+            pretrained_path=(args.pretrained_model_path, args.pretrained_num_classes),
+        )
     else:
-        if args.dataset[0] == 'all':
-            datasets = [ds for ds in agml.data.public_data_sources(
-                ml_task = 'object_detection')]
+        if args.dataset[0] == "all":
+            datasets = [
+                ds for ds in agml.data.public_data_sources(ml_task="object_detection")
+            ]
         else:
             datasets = args.dataset
         for ds in datasets:
-            train(ds,
-                  epochs = args.epochs,
-                  save_dir = args.checkpoint_dir,
-                  overwrite = args.regenerate_existing,
-                  pretrained_path = (args.pretrained_model_path,
-                                     args.pretrained_num_classes))
-
-
-
-
+            train(
+                ds,
+                epochs=args.epochs,
+                save_dir=args.checkpoint_dir,
+                overwrite=args.regenerate_existing,
+                pretrained_path=(
+                    args.pretrained_model_path,
+                    args.pretrained_num_classes,
+                ),
+            )
diff --git a/experiments/benchmarking/detection_lightning_multiple.py b/experiments/benchmarking/detection_lightning_multiple.py
index 86024e26..dcb69d9d 100644
--- a/experiments/benchmarking/detection_lightning_multiple.py
+++ b/experiments/benchmarking/detection_lightning_multiple.py
@@ -19,46 +19,43 @@
 2. https://gist.github.com/Chris-hughes10/73628b1d8d6fc7d359b3dcbbbb8869d7
 """
 
-import os
 import argparse
+import os
 import warnings
 from typing import List, Union
 
+import albumentations as A
 import numpy as np
-from PIL import Image
-
-import torch
-from torch.utils.data import Dataset, DataLoader
 import pytorch_lightning as pl
-from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger
-from mean_average_precision_torch import MeanAveragePrecision as MAP
-
-import agml
-import albumentations as A
+import torch
+from PIL import Image
 from albumentations.pytorch import ToTensorV2
-
-from effdet import get_efficientdet_config, EfficientDet, DetBenchTrain, create_model_from_config
+from effdet import DetBenchTrain, EfficientDet, create_model_from_config, get_efficientdet_config
 from effdet.efficientdet import HeadNet
-
 from ensemble_boxes import ensemble_boxes_wbf
+from mean_average_precision_torch import MeanAveragePrecision as MAP
+from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger
+from tools import MetricLogger, auto_move_data, checkpoint_dir, gpus
+from torch.utils.data import DataLoader, Dataset
 
-from tools import gpus, checkpoint_dir, MetricLogger, auto_move_data
-
+import agml
 
 # Constants
 IMAGE_SIZE = 512
 
 
-def create_model(num_classes = 1, architecture = "tf_efficientdet_d4", pretrained = False):
+def create_model(num_classes=1, architecture="tf_efficientdet_d4", pretrained=False):
     config = get_efficientdet_config(architecture)
-    config.update({'image_size': (IMAGE_SIZE, IMAGE_SIZE)})
+    config.update({"image_size": (IMAGE_SIZE, IMAGE_SIZE)})
 
     print(config)
 
-    net = create_model_from_config(config, pretrained = pretrained, num_classes = num_classes)
+    net = create_model_from_config(
+        config, pretrained=pretrained, num_classes=num_classes
+    )
     net.class_net = HeadNet(
         config,
-        num_outputs = num_classes,
+        num_outputs=num_classes,
     )
     return DetBenchTrain(net, config)
 
@@ -75,65 +72,79 @@ def __len__(self) -> int:
     def get_image_and_labels_by_idx(self, index):
         image, annotation = self.loader[index]
         image = Image.fromarray(image)
-        bboxes = np.array(annotation['bbox']).astype(np.int32)
+        bboxes = np.array(annotation["bbox"]).astype(np.int32)
         x_min = bboxes[:, 0]
         y_min = bboxes[:, 1]
         x_max = bboxes[:, 2] + x_min
         y_max = bboxes[:, 3] + y_min
         x_min, y_min = np.clip(x_min, 0, image.width), np.clip(y_min, 0, image.height)
         x_max, y_max = np.clip(x_max, 0, image.width), np.clip(y_max, 0, image.height)
-        bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis = 0)
-        class_labels = np.array(annotation['category_id']).squeeze()
+        bboxes = np.dstack((x_min, y_min, x_max, y_max)).squeeze(axis=0)
+        class_labels = np.array(annotation["category_id"]).squeeze()
         return image, bboxes, class_labels, index
 
 
-def get_transforms(mode = 'inference'):
+def get_transforms(mode="inference"):
     """Returns a set of transforms corresponding to the mode."""
-    if mode == 'train':
+    if mode == "train":
         return A.Compose(
-            [A.HorizontalFlip(p = 0.5),
-             A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0,
-            bbox_params = A.BboxParams(
-                format = "pascal_voc", min_area = 0,
-                min_visibility = 0, label_fields = ["labels"]))
-
-    elif mode in ['val', 'validation']:
+            [
+                A.HorizontalFlip(p=0.5),
+                A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1),
+                ToTensorV2(p=1),
+            ],
+            p=1.0,
+            bbox_params=A.BboxParams(
+                format="pascal_voc",
+                min_area=0,
+                min_visibility=0,
+                label_fields=["labels"],
+            ),
+        )
+
+    elif mode in ["val", "validation"]:
         return A.Compose(
-            [A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0,
-            bbox_params = A.BboxParams(
-                format = "pascal_voc", min_area = 0,
-                min_visibility = 0, label_fields = ["labels"]))
+            [A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1), ToTensorV2(p=1)],
+            p=1.0,
+            bbox_params=A.BboxParams(
+                format="pascal_voc",
+                min_area=0,
+                min_visibility=0,
+                label_fields=["labels"],
+            ),
+        )
 
-    elif mode == 'inference':
+    elif mode == "inference":
         return A.Compose(
-            [A.Resize(height = IMAGE_SIZE, width = IMAGE_SIZE, p = 1),
-             ToTensorV2(p = 1)], p = 1.0)
+            [A.Resize(height=IMAGE_SIZE, width=IMAGE_SIZE, p=1), ToTensorV2(p=1)], p=1.0
+        )
 
 
 class EfficientDetDataset(Dataset):
-    def __init__(self, adaptor, transforms = None):
+    def __init__(self, adaptor, transforms=None):
         self.ds = adaptor
         if transforms is None:
-            transforms = get_transforms('val')
+            transforms = get_transforms("val")
         self.transforms = transforms
 
     def __len__(self):
         return len(self.ds)
 
     def __getitem__(self, index):
-        image, pascal_bboxes, class_labels, image_id = \
+        image, pascal_bboxes, class_labels, image_id = (
             self.ds.get_image_and_labels_by_idx(index)
+        )
 
         # Add a label dimension for consistency.
         if class_labels.ndim == 0:
-            class_labels = np.expand_dims(class_labels, axis = 0)
+            class_labels = np.expand_dims(class_labels, axis=0)
 
         # Construct the sample.
         sample = {
-            "image": np.array(image, dtype = np.float32),
-            "bboxes": pascal_bboxes, "labels": class_labels}
+            "image": np.array(image, dtype=np.float32),
+            "bboxes": pascal_bboxes,
+            "labels": class_labels,
+        }
 
         try:
             sample = self.transforms(**sample)
@@ -152,69 +163,69 @@ def __getitem__(self, index):
 
         # Convert to yxyx from xyxy.
         _, new_h, new_w = image.shape
-        sample["bboxes"][:, [0, 1, 2, 3]] = \
-            sample["bboxes"][:, [1, 0, 3, 2]]
+        sample["bboxes"][:, [0, 1, 2, 3]] = sample["bboxes"][:, [1, 0, 3, 2]]
 
         # Create the target from the annotations.
         target = {
-            "bboxes": torch.as_tensor(sample["bboxes"], dtype = torch.float32),
-            "labels": torch.as_tensor(labels), "image_id": torch.tensor([image_id]),
-            "img_size": (new_h, new_w), "img_scale": torch.tensor([1.0])}
+            "bboxes": torch.as_tensor(sample["bboxes"], dtype=torch.float32),
+            "labels": torch.as_tensor(labels),
+            "image_id": torch.tensor([image_id]),
+            "img_size": (new_h, new_w),
+            "img_scale": torch.tensor([1.0]),
+        }
         return image, target, image_id
 
 
 class EfficientDetDataModule(pl.LightningDataModule):
     """A `LightningDataModule` for the `LightningModule`."""
 
-    def __init__(self,
-                 train_dataset_adaptor,
-                 validation_dataset_adaptor,
-                 train_transforms = None,
-                 val_transforms = None,
-                 num_workers = 4,
-                 batch_size = 8):
+    def __init__(
+        self,
+        train_dataset_adaptor,
+        validation_dataset_adaptor,
+        train_transforms=None,
+        val_transforms=None,
+        num_workers=4,
+        batch_size=8,
+    ):
         self.train_ds = train_dataset_adaptor
         self.valid_ds = validation_dataset_adaptor
         if train_transforms is None:
-            train_transforms = get_transforms('train')
+            train_transforms = get_transforms("train")
         self.train_tfms = train_transforms
         if val_transforms is None:
-            val_transforms = get_transforms('val')
+            val_transforms = get_transforms("val")
         self.val_tfms = val_transforms
         self.num_workers = num_workers
         self.batch_size = batch_size
         super().__init__()
 
     def train_dataset(self) -> EfficientDetDataset:
-        return EfficientDetDataset(
-            adaptor = self.train_ds,
-            transforms = self.train_tfms)
+        return EfficientDetDataset(adaptor=self.train_ds, transforms=self.train_tfms)
 
     def train_dataloader(self) -> DataLoader:
         return DataLoader(
             self.train_dataset(),
-            batch_size = self.batch_size,
-            shuffle = True,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self.num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=self.batch_size,
+            shuffle=True,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self.num_workers,
+            collate_fn=self.collate_fn,
         )
 
     def val_dataset(self) -> EfficientDetDataset:
-        return EfficientDetDataset(
-            adaptor = self.valid_ds,
-            transforms = self.val_tfms)
+        return EfficientDetDataset(adaptor=self.valid_ds, transforms=self.val_tfms)
 
     def val_dataloader(self) -> DataLoader:
         return DataLoader(
             self.val_dataset(),
-            batch_size = self.batch_size,
-            shuffle = False,
-            pin_memory = True,
-            drop_last = True,
-            num_workers = self.num_workers,
-            collate_fn = self.collate_fn,
+            batch_size=self.batch_size,
+            shuffle=False,
+            pin_memory=True,
+            drop_last=True,
+            num_workers=self.num_workers,
+            collate_fn=self.collate_fn,
         )
 
     @staticmethod
@@ -229,39 +240,43 @@ def collate_fn(batch):
         img_scale = torch.tensor([target["img_scale"] for target in targets]).float()
 
         annotations = {
-            "bbox": boxes, "cls": labels,
-            "img_size": img_size, "img_scale": img_scale}
+            "bbox": boxes,
+            "cls": labels,
+            "img_size": img_size,
+            "img_scale": img_scale,
+        }
         return images, annotations, targets, image_ids
 
 
 class EfficientDetModel(pl.LightningModule):
-    def __init__(self,
-                 num_classes = 1,
-                 confidence_threshold = 0.3,
-                 learning_rate = 0.0002,
-                 wbf_iou_threshold = 0.44,
-                 inference_transforms = None,
-                 architecture = 'efficientdet_d4',
-                 save_dir = None,
-                 pretrained = False,
-                 validation_dataset_adaptor = None):
+    def __init__(
+        self,
+        num_classes=1,
+        confidence_threshold=0.3,
+        learning_rate=0.0002,
+        wbf_iou_threshold=0.44,
+        inference_transforms=None,
+        architecture="efficientdet_d4",
+        save_dir=None,
+        pretrained=False,
+        validation_dataset_adaptor=None,
+    ):
         super().__init__()
         self.model = create_model(
-            num_classes, architecture = architecture,
-            pretrained = pretrained)
+            num_classes, architecture=architecture, pretrained=pretrained
+        )
         self.confidence_threshold = confidence_threshold
         self.lr = learning_rate
         self.wbf_iou_threshold = wbf_iou_threshold
         if inference_transforms is None:
-            inference_transforms = get_transforms('inference')
+            inference_transforms = get_transforms("inference")
         self.inference_tfms = inference_transforms
 
         # Construct the metric.
         self.val_dataset_adaptor = None
         if validation_dataset_adaptor is not None:
             # Add a metric calculator.
-            self.val_dataset_adaptor = AgMLDatasetAdaptor(
-                validation_dataset_adaptor)
+            self.val_dataset_adaptor = AgMLDatasetAdaptor(validation_dataset_adaptor)
             self.map = MAP()
         self._sanity_check_passed = False
 
@@ -270,7 +285,7 @@ def forward(self, images, targets):
         return self.model(images, targets)
 
     def configure_optimizers(self):
-        return torch.optim.AdamW(self.model.parameters(), lr = self.lr)
+        return torch.optim.AdamW(self.model.parameters(), lr=self.lr)
 
     def training_step(self, batch, batch_idx):
         # Run a forward pass through the model.
@@ -278,13 +293,29 @@ def training_step(self, batch, batch_idx):
         losses = self.model(images, annotations)
 
         # Calculate and log losses.
-        self.log("train_loss", losses["loss"], on_step = True,
-                 on_epoch = True, prog_bar = True, logger = True)
-        self.log("train_class_loss", losses["class_loss"],
-                 on_step = True, on_epoch = True, logger = True)
-        self.log("train_box_loss", losses["box_loss"], on_step = True,
-                 on_epoch = True, logger = True)
-        return losses['loss']
+        self.log(
+            "train_loss",
+            losses["loss"],
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+        )
+        self.log(
+            "train_class_loss",
+            losses["class_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+        )
+        self.log(
+            "train_box_loss",
+            losses["box_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+        )
+        return losses["loss"]
 
     @torch.no_grad()
     def validation_step(self, batch, batch_idx):
@@ -295,19 +326,29 @@ def validation_step(self, batch, batch_idx):
         # Update the metric.
         if self.val_dataset_adaptor is not None and self._sanity_check_passed:
             for idx in image_ids:
-                image, truth_boxes, truth_cls, _ = \
+                image, truth_boxes, truth_cls, _ = (
                     self.val_dataset_adaptor.get_image_and_labels_by_idx(idx)
+                )
                 pred_box, pred_labels, pred_conf = self.predict([image])
                 if not isinstance(pred_labels[0], float):
-                    pred_box, pred_labels, pred_conf = pred_box[0], pred_labels[0], pred_conf[0]
+                    pred_box, pred_labels, pred_conf = (
+                        pred_box[0],
+                        pred_labels[0],
+                        pred_conf[0],
+                    )
                 if truth_cls.ndim == 0:
                     truth_cls = np.expand_dims(truth_cls, 0)
-                metric_update_values = \
-                    dict(boxes = torch.tensor(pred_box, dtype = torch.float32),
-                         labels = torch.tensor(pred_labels, dtype = torch.int32),
-                         scores = torch.tensor(pred_conf)), \
-                    dict(boxes = torch.tensor(truth_boxes, dtype = torch.float32),
-                         labels = torch.tensor(truth_cls, dtype = torch.int32))
+                metric_update_values = (
+                    dict(
+                        boxes=torch.tensor(pred_box, dtype=torch.float32),
+                        labels=torch.tensor(pred_labels, dtype=torch.int32),
+                        scores=torch.tensor(pred_conf),
+                    ),
+                    dict(
+                        boxes=torch.tensor(truth_boxes, dtype=torch.float32),
+                        labels=torch.tensor(truth_cls, dtype=torch.int32),
+                    ),
+                )
                 self.map.update(*metric_update_values)
 
         batch_predictions = {
@@ -321,16 +362,33 @@ def validation_step(self, batch, batch_idx):
             "box_loss": outputs["box_loss"].detach(),
         }
 
-        self.log("valid_loss", outputs["loss"], on_step = True, on_epoch = True,
-                 prog_bar = True, logger = True, sync_dist = True)
-        self.log("valid_class_loss", logging_losses["class_loss"],
-                 on_step = True, on_epoch = True,
-                 logger = True, sync_dist = True)
-        self.log("valid_box_loss", logging_losses["box_loss"],
-                 on_step = True, on_epoch = True,
-                 logger = True, sync_dist = True)
+        self.log(
+            "valid_loss",
+            outputs["loss"],
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+            sync_dist=True,
+        )
+        self.log(
+            "valid_class_loss",
+            logging_losses["class_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+            sync_dist=True,
+        )
+        self.log(
+            "valid_box_loss",
+            logging_losses["box_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+            sync_dist=True,
+        )
 
-        return {'loss': outputs["loss"], 'batch_predictions': batch_predictions}
+        return {"loss": outputs["loss"], "batch_predictions": batch_predictions}
 
     def predict(self, images: Union[torch.Tensor, List]):
         """Runs inference on a set of images.
@@ -347,20 +405,27 @@ def predict(self, images: Union[torch.Tensor, List]):
         """
         if isinstance(images, list):
             image_sizes = [(image.size[1], image.size[0]) for image in images]
-            images_tensor = torch.stack([
-                self.inference_tfms(
-                    image = np.array(image, dtype = np.float32),
-                )["image"] for image in images])
+            images_tensor = torch.stack(
+                [
+                    self.inference_tfms(
+                        image=np.array(image, dtype=np.float32),
+                    )["image"]
+                    for image in images
+                ]
+            )
             return self._run_inference(images_tensor, image_sizes)
         elif isinstance(images, torch.Tensor):
             image_tensor = images
             if image_tensor.ndim == 3:
                 image_tensor = image_tensor.unsqueeze(0)
-            if image_tensor.shape[-1] != IMAGE_SIZE \
-                    or image_tensor.shape[-2] != IMAGE_SIZE:
+            if (
+                image_tensor.shape[-1] != IMAGE_SIZE
+                or image_tensor.shape[-2] != IMAGE_SIZE
+            ):
                 raise ValueError(
                     f"Input tensors must be of shape "
-                    f"(N, 3, {IMAGE_SIZE}, {IMAGE_SIZE})")
+                    f"(N, 3, {IMAGE_SIZE}, {IMAGE_SIZE})"
+                )
 
             num_images = image_tensor.shape[0]
             image_sizes = [(IMAGE_SIZE, IMAGE_SIZE)] * num_images
@@ -368,40 +433,50 @@ def predict(self, images: Union[torch.Tensor, List]):
         else:
             raise TypeError(
                 "Expected either a list of images or a "
-                "torch.Tensor of images for `predict()`.")
+                "torch.Tensor of images for `predict()`."
+            )
 
     def _run_inference(self, images_tensor, image_sizes):
         dummy_targets = self._create_dummy_inference_targets(
-            images_tensor.shape[0], self.device, IMAGE_SIZE)
+            images_tensor.shape[0], self.device, IMAGE_SIZE
+        )
 
-        detections = self.model(
-            images_tensor.to(self.device), dummy_targets)["detections"]
+        detections = self.model(images_tensor.to(self.device), dummy_targets)[
+            "detections"
+        ]
 
-        predicted_bboxes, predicted_class_confidences, predicted_class_labels = \
+        predicted_bboxes, predicted_class_confidences, predicted_class_labels = (
             self.post_process_detections(detections)
+        )
         scaled_bboxes = self._rescale_bboxes(
-            predicted_bboxes = predicted_bboxes,
-            image_sizes = image_sizes)
+            predicted_bboxes=predicted_bboxes, image_sizes=image_sizes
+        )
         return scaled_bboxes, predicted_class_labels, predicted_class_confidences
 
     @staticmethod
     def _create_dummy_inference_targets(num_images, device, size):
         return {
             "bbox": [
-                torch.tensor([[0.0, 0.0, 0.0, 0.0]], device = device)
+                torch.tensor([[0.0, 0.0, 0.0, 0.0]], device=device)
                 for _ in range(num_images)
             ],
-            "cls": [torch.tensor([1.0], device = device) for _ in range(num_images)],
+            "cls": [torch.tensor([1.0], device=device) for _ in range(num_images)],
             "img_size": torch.tensor(
-                [(size, size)] * num_images, device = device).float(),
-            "img_scale": torch.ones(num_images, device = device).float(),
+                [(size, size)] * num_images, device=device
+            ).float(),
+            "img_scale": torch.ones(num_images, device=device).float(),
         }
 
     def post_process_detections(self, detections):
-        predictions = [self._postprocess_single_prediction_detections(d) for d in detections]
-
-        predicted_bboxes, predicted_class_confidences, predicted_class_labels = self.run_wbf(
-            predictions, image_size = IMAGE_SIZE, iou_thr = self.wbf_iou_threshold)
+        predictions = [
+            self._postprocess_single_prediction_detections(d) for d in detections
+        ]
+
+        predicted_bboxes, predicted_class_confidences, predicted_class_labels = (
+            self.run_wbf(
+                predictions, image_size=IMAGE_SIZE, iou_thr=self.wbf_iou_threshold
+            )
+        )
         return predicted_bboxes, predicted_class_confidences, predicted_class_labels
 
     def _postprocess_single_prediction_detections(self, detections):
@@ -425,16 +500,24 @@ def _rescale_bboxes(predicted_bboxes, image_sizes):
             im_h, im_w = img_dims
             if len(bboxes) > 0:
                 scaled_bboxes.append(
-                    (np.array(bboxes) * [
-                        im_w / IMAGE_SIZE, im_h / IMAGE_SIZE,
-                        im_w / IMAGE_SIZE, im_h / IMAGE_SIZE
-                    ]).tolist())
+                    (
+                        np.array(bboxes)
+                        * [
+                            im_w / IMAGE_SIZE,
+                            im_h / IMAGE_SIZE,
+                            im_w / IMAGE_SIZE,
+                            im_h / IMAGE_SIZE,
+                        ]
+                    ).tolist()
+                )
             else:
                 scaled_bboxes.append(bboxes)
         return scaled_bboxes
 
     @staticmethod
-    def run_wbf(predictions, image_size = 512, iou_thr = 0.44, skip_box_thr = 0.43, weights = None):
+    def run_wbf(
+        predictions, image_size=512, iou_thr=0.44, skip_box_thr=0.43, weights=None
+    ):
         bboxes, confidences, class_labels = [], [], []
 
         for prediction in predictions:
@@ -443,8 +526,13 @@ def run_wbf(predictions, image_size = 512, iou_thr = 0.44, skip_box_thr = 0.43,
             labels = [prediction["classes"].tolist()]
 
             boxes, scores, labels = ensemble_boxes_wbf.weighted_boxes_fusion(
-                boxes, scores, labels, weights = weights,
-                iou_thr = iou_thr, skip_box_thr = skip_box_thr)
+                boxes,
+                scores,
+                labels,
+                weights=weights,
+                iou_thr=iou_thr,
+                skip_box_thr=skip_box_thr,
+            )
             boxes = boxes * (image_size - 1)
             bboxes.append(boxes.tolist())
             confidences.append(scores.tolist())
@@ -456,60 +544,60 @@ def on_validation_epoch_end(self) -> None:
         if not self._sanity_check_passed:
             self._sanity_check_passed = True
             return
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.compile_epoch()
-        if hasattr(self, 'map'):
+        if hasattr(self, "map"):
             map = self.map.compute().detach().cpu().numpy().item()
-            self.log("map", map, prog_bar = True,
-                     on_epoch = True,
-                     logger = True, sync_dist = True)
+            self.log(
+                "map", map, prog_bar=True, on_epoch=True, logger=True, sync_dist=True
+            )
             self.map.reset()
 
     def on_fit_end(self) -> None:
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.save()
         self.map.reset()
 
     def get_progress_bar_dict(self):
         p_bar = super(EfficientDetModel, self).get_progress_bar_dict()
-        p_bar.pop('v_num', None)
+        p_bar.pop("v_num", None)
         return p_bar
 
 
 # Calculate and log the metrics.
 class DetectionMetricLogger(MetricLogger):
     def update_metrics(self, y_pred, y_true) -> None:
-        self.metrics['map'].update(y_pred, y_true)
+        self.metrics["map"].update(y_pred, y_true)
 
 
-def train(dataset, epochs, save_dir = None, overwrite = None, generalize_detections = False):
+def train(dataset, epochs, save_dir=None, overwrite=None, generalize_detections=False):
     """Constructs the training loop and trains a model."""
     save_dir = checkpoint_dir(None, save_dir)
-    log_dir = save_dir.replace('checkpoints', 'logs')
+    log_dir = save_dir.replace("checkpoints", "logs")
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Set up the checkpoint saving callback.
     callbacks = [
         pl.callbacks.ModelCheckpoint(
-            dirpath = save_dir, mode = 'min',
-            filename = f"{dataset}" + "-epoch{epoch:02d}-valid_loss_{valid_loss:.2f}",
-            monitor = 'valid_loss',
-            save_top_k = 3,
-            auto_insert_metric_name = False
+            dirpath=save_dir,
+            mode="min",
+            filename=f"{dataset}" + "-epoch{epoch:02d}-valid_loss_{valid_loss:.2f}",
+            monitor="valid_loss",
+            save_top_k=3,
+            auto_insert_metric_name=False,
         )
     ]
 
     # Create the loggers.
-    loggers = [
-        CSVLogger(log_dir),
-        TensorBoardLogger(log_dir)
-    ]
+    loggers = [CSVLogger(log_dir), TensorBoardLogger(log_dir)]
 
     # Construct the data.
     print(f"Saving to {log_dir}.")
@@ -521,68 +609,79 @@ def train(dataset, epochs, save_dir = None, overwrite = None, generalize_detecti
         print("Generalizing class detections.")
         loader.generalize_class_detections()
         num_classes = 1
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
+    loader.split(train=0.8, val=0.1, test=0.1)
     dm = EfficientDetDataModule(
-        train_dataset_adaptor = AgMLDatasetAdaptor(loader.train_data),
-        validation_dataset_adaptor = AgMLDatasetAdaptor(loader.val_data),
-        num_workers = 12, batch_size = 4)
+        train_dataset_adaptor=AgMLDatasetAdaptor(loader.train_data),
+        validation_dataset_adaptor=AgMLDatasetAdaptor(loader.val_data),
+        num_workers=12,
+        batch_size=4,
+    )
 
     # Construct the model.
     model = EfficientDetModel(
-        num_classes = num_classes,
-        architecture = 'tf_efficientdet_d4',
-        save_dir = save_dir,
-        pretrained = True,
-        validation_dataset_adaptor = loader.val_data)
+        num_classes=num_classes,
+        architecture="tf_efficientdet_d4",
+        save_dir=save_dir,
+        pretrained=True,
+        validation_dataset_adaptor=loader.val_data,
+    )
 
     # Create the trainer and train the model.
     msg = f"Training dataset {dataset}!"
     print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
     trainer = pl.Trainer(
-        max_epochs = epochs, gpus = gpus(None),
-        callbacks = callbacks, logger = loggers)
+        max_epochs=epochs, gpus=gpus(None), callbacks=callbacks, logger=loggers
+    )
     trainer.fit(model, dm)
 
     # Save the model state.
-    torch.save(model.state_dict(), os.path.join(save_dir, 'model_state.pth'))
+    torch.save(model.state_dict(), os.path.join(save_dir, "model_state.pth"))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--regenerate-existing', action = 'store_true',
-        default = False, help = "Whether to re-generate existing benchmarks.")
+        "--regenerate-existing",
+        action="store_true",
+        default=False,
+        help="Whether to re-generate existing benchmarks.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 20,
-        help = "How many epochs to train for. Default is 20.")
+        "--epochs",
+        type=int,
+        default=20,
+        help="How many epochs to train for. Default is 20.",
+    )
     ap.add_argument(
-        '--generalize-detections', action = 'store_true',
-        default = False, help = "Whether to generalize class labels.")
+        "--generalize-detections",
+        action="store_true",
+        default=False,
+        help="Whether to generalize class labels.",
+    )
     args = ap.parse_args()
 
     # Train the model.
-    if args.dataset[0] == 'except':
+    if args.dataset[0] == "except":
         exclude_datasets = args.dataset[1:]
         datasets = [
-            dataset.name for dataset in agml.data.public_data_sources(
-                ml_task = 'object_detection')
-            if dataset.name not in exclude_datasets]
+            dataset.name
+            for dataset in agml.data.public_data_sources(ml_task="object_detection")
+            if dataset.name not in exclude_datasets
+        ]
     else:
         datasets = args.dataset
     train(
-        dataset = datasets,
-        epochs = args.epochs,
-        save_dir = args.checkpoint_dir,
-        overwrite = args.regenerate_existing,
-        generalize_detections = args.generalize_detections)
-
-
-
-
-
+        dataset=datasets,
+        epochs=args.epochs,
+        save_dir=args.checkpoint_dir,
+        overwrite=args.regenerate_existing,
+        generalize_detections=args.generalize_detections,
+    )
diff --git a/experiments/benchmarking/detection_lightning_ssd.py b/experiments/benchmarking/detection_lightning_ssd.py
index 686042c3..0b37f393 100644
--- a/experiments/benchmarking/detection_lightning_ssd.py
+++ b/experiments/benchmarking/detection_lightning_ssd.py
@@ -12,16 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import os
 
+import albumentations as A
 import numpy as np
+import pytorch_lightning as pl
 import torch
 import torch.nn as nn
 from torchvision.models.detection import ssd300_vgg16
-import pytorch_lightning as pl
+
 import agml
-import albumentations as A
 
 
 class EfficientDetTransfer(nn.Module):
@@ -30,16 +31,18 @@ class EfficientDetTransfer(nn.Module):
     This is the base benchmarking model for semantic segmentation,
     using the DeepLabV3 model with a ResNet50 backbone.
     """
+
     def __init__(self):
         super(EfficientDetTransfer, self).__init__()
         self.base = ssd300_vgg16(pretrained=False)
 
-    def forward(self, x, y, **kwargs): # noqa
+    def forward(self, x, y, **kwargs):  # noqa
         return self.base(x, y)
 
 
 class DetectionBenchmark(pl.LightningModule):
     """Represents an image classification benchmark model."""
+
     def __init__(self):
         # Initialize the module.
         super(DetectionBenchmark, self).__init__()
@@ -50,34 +53,27 @@ def __init__(self):
     def forward(self, x, target):
         return self.net(x, target)
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = process_data(*batch)
         loss_dict = self(x, y)
-        self.log('class_loss', loss_dict['classification'], prog_bar = True)
-        self.log('reg_loss', loss_dict['bbox_regression'], prog_bar = True)
-        return {
-            'loss': sum(i for i in loss_dict.values()),
-            'log': loss_dict
-        }
-
-    def validation_step(self, batch, *args, **kwargs): # noqa
+        self.log("class_loss", loss_dict["classification"], prog_bar=True)
+        self.log("reg_loss", loss_dict["bbox_regression"], prog_bar=True)
+        return {"loss": sum(i for i in loss_dict.values()), "log": loss_dict}
+
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = process_data(*batch)
         self.net.train()
         loss_dict = self(x, y)
-        self.log('class_loss', loss_dict['classification'], prog_bar = True)
-        self.log('reg_loss', loss_dict['bbox_regression'], prog_bar = True)
-        return {
-            'loss': sum(i for i in loss_dict.values()),
-            'log': loss_dict
-        }
+        self.log("class_loss", loss_dict["classification"], prog_bar=True)
+        self.log("reg_loss", loss_dict["bbox_regression"], prog_bar=True)
+        return {"loss": sum(i for i in loss_dict.values()), "log": loss_dict}
 
     def configure_optimizers(self):
         return torch.optim.Adam(self.net.parameters())
 
     def get_progress_bar_dict(self):
-        tqdm_dict = super(DetectionBenchmark, self)\
-            .get_progress_bar_dict()
-        tqdm_dict.pop('v_num', None)
+        tqdm_dict = super(DetectionBenchmark, self).get_progress_bar_dict()
+        tqdm_dict.pop("v_num", None)
         return tqdm_dict
 
 
@@ -88,14 +84,14 @@ def accuracy(output, target):
         _, pred = torch.topk(output, 1, 1)
         pred = pred.t()
         correct = pred.eq(target.view(1, -1).expand_as(pred))
-        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim = True)
+        correct_k = correct[:1].reshape(-1).float().sum(0, keepdim=True)
         return correct_k.mul_(100.0 / batch_size)
 
 
 # Transform to swap bounding box order from `xyxy` to `yxyx` # noqa
 def bbox_swap(coco):
-    x1, y1, w, h = coco['bbox'].T
-    coco['bbox'] = np.squeeze(np.dstack((x1, y1, x1 + w, y1 + h)))
+    x1, y1, w, h = coco["bbox"].T
+    coco["bbox"] = np.squeeze(np.dstack((x1, y1, x1 + w, y1 + h)))
     return coco
 
 
@@ -104,58 +100,61 @@ def bbox_swap(coco):
 # is used directly in the training loop.
 def _make_boxes(b):
     if b.ndim == 1:
-        return torch.unsqueeze(b, dim = 0)
+        return torch.unsqueeze(b, dim=0)
     return b
 
+
 def process_data(image, coco):
-    return torch.unbind(image, dim = 0), [
-        {'boxes': _make_boxes(d['bbox'].float()),
-         'labels': d['category_id'].long()} for d in coco]
+    return torch.unbind(image, dim=0), [
+        {"boxes": _make_boxes(d["bbox"].float()), "labels": d["category_id"].long()}
+        for d in coco
+    ]
 
 
 # Build the data loaders.
 def build_loaders(name):
     loader = agml.data.AgMLDataLoader(name)
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
+    loader.split(train=0.8, val=0.1, test=0.1)
     loader.batch(4)
     loader.resize_images((256, 256))
-    loader.normalize_images(method = 'scale')
+    loader.normalize_images(method="scale")
     train_data = loader.train_data
-    train_data.transform(transform = A.Compose([
-        A.RandomRotate90()
-    ], bbox_params = A.BboxParams('coco')))
-    train_data.transform(target_transform = bbox_swap)
+    train_data.transform(
+        transform=A.Compose([A.RandomRotate90()], bbox_params=A.BboxParams("coco"))
+    )
+    train_data.transform(target_transform=bbox_swap)
     train_ds = train_data.copy().as_torch_dataset()
     val_ds = loader.val_data.as_torch_dataset()
-    val_ds.transform(target_transform = bbox_swap)
+    val_ds.transform(target_transform=bbox_swap)
     val_ds.shuffle_data = False
     test_ds = loader.test_data.as_torch_dataset()
     return train_ds, val_ds, test_ds
 
 
-def train(dataset, pretrained, epochs, save_dir = None):
+def train(dataset, pretrained, epochs, save_dir=None):
     """Constructs the training loop and trains a model."""
     if save_dir is None:
-        if os.path.isdir('/data2'):
+        if os.path.isdir("/data2"):
             save_dir = os.path.join(f"/data2/amnjoshi/checkpoints/{dataset}")
         else:
-            save_dir = os.path.join(os.path.dirname(__file__), 'logs')
-        os.makedirs(save_dir, exist_ok = True)
+            save_dir = os.path.join(os.path.dirname(__file__), "logs")
+        os.makedirs(save_dir, exist_ok=True)
 
     # Set up the checkpoint saving callback.
     callbacks = [
         pl.callbacks.ModelCheckpoint(
-            dirpath = save_dir, mode = 'min',
-            filename = f"{dataset}" + "-epoch{epoch:02d}-val_loss_{val_loss:.2f}",
-            monitor = 'val_loss',
-            save_top_k = 3,
-            auto_insert_metric_name = False
+            dirpath=save_dir,
+            mode="min",
+            filename=f"{dataset}" + "-epoch{epoch:02d}-val_loss_{val_loss:.2f}",
+            monitor="val_loss",
+            save_top_k=3,
+            auto_insert_metric_name=False,
         ),
         pl.callbacks.EarlyStopping(
-            monitor = 'val_loss',
-            min_delta = 0.001,
-            patience = 3,
-        )
+            monitor="val_loss",
+            min_delta=0.001,
+            patience=3,
+        ),
     ]
 
     # Construct the model.
@@ -165,50 +164,40 @@ def train(dataset, pretrained, epochs, save_dir = None):
     train_ds, val_ds, test_ds = build_loaders(dataset)
 
     # Create the trainer and train the model.
-    trainer = pl.Trainer(
-        max_epochs = epochs, gpus = 0, callbacks = callbacks)
-    trainer.fit(
-        model = model,
-        train_dataloaders = train_ds,
-        val_dataloaders = val_ds
-    )
+    trainer = pl.Trainer(max_epochs=epochs, gpus=0, callbacks=callbacks)
+    trainer.fit(model=model, train_dataloaders=train_ds, val_dataloaders=val_ds)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     from agml.backend import set_seed
+
     set_seed(0)
 
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, help = "The name of the dataset.")
-    ap.add_argument(
-        '--pretrained', action = 'store_true',
-        default = False, help = "Whether to load a pretrained model.")
+        "--pretrained",
+        action="store_true",
+        default=False,
+        help="Whether to load a pretrained model.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 50,
-        help = "How many epochs to train for. Default is 50.")
+        "--epochs",
+        type=int,
+        default=50,
+        help="How many epochs to train for. Default is 50.",
+    )
     args = ap.parse_args()
     args.dataset = "apple_detection_usa"
 
     # Train the model.
-    train(args.dataset,
-          args.pretrained,
-          epochs = args.epochs,
-          save_dir = args.checkpoint_dir)
-
-
-
-
-
-
-
-
-
-
-
-
-
+    train(
+        args.dataset, args.pretrained, epochs=args.epochs, save_dir=args.checkpoint_dir
+    )
diff --git a/experiments/benchmarking/detection_modeling.py b/experiments/benchmarking/detection_modeling.py
index 9616d12d..e9a66a73 100644
--- a/experiments/benchmarking/detection_modeling.py
+++ b/experiments/benchmarking/detection_modeling.py
@@ -15,10 +15,9 @@
 import os
 from typing import Union
 
-import torch
 import numpy as np
-
-from effdet import get_efficientdet_config, DetBenchTrain, create_model_from_config
+import torch
+from effdet import DetBenchTrain, create_model_from_config, get_efficientdet_config
 
 from agml.models.detection import DetectionModel
 from experiments.benchmarking.mean_average_precision_torch import MeanAveragePrecision
@@ -26,21 +25,25 @@
 
 class DetectionTrainingModel(DetectionModel):
     """Wraps an `EfficientDet` model for a training experiment."""
-    def __init__(self,
-                 num_classes: int = 1,
-                 pretrained_weights: str = None,
-                 confidence_threshold: float = 0.3,
-                 learning_rate: float = 0.0002,
-                 wbf_iou_threshold: float = 0.44,
-                 **kwargs):
+
+    def __init__(
+        self,
+        num_classes: int = 1,
+        pretrained_weights: str = None,
+        confidence_threshold: float = 0.3,
+        learning_rate: float = 0.0002,
+        wbf_iou_threshold: float = 0.44,
+        **kwargs,
+    ):
         # Initialize the super module.
-        super(DetectionTrainingModel, self).__init__(model_initialized = True)
+        super(DetectionTrainingModel, self).__init__(model_initialized=True)
 
         # Initialize the model using the provided arguments for customizability.
         self.model = self.make_model(
-            num_classes = num_classes,
-            pretrained_weights = pretrained_weights,
-            architecture = kwargs.get('architecture', 'tf_efficientdet_d4'))
+            num_classes=num_classes,
+            pretrained_weights=pretrained_weights,
+            architecture=kwargs.get("architecture", "tf_efficientdet_d4"),
+        )
 
         # Set the training parameters.
         self._confidence_threshold = confidence_threshold
@@ -53,41 +56,47 @@ def __init__(self,
         self._sanity_check_passed = False
 
     @staticmethod
-    def make_model(num_classes: int,
-                   pretrained_weights: str,
-                   image_size: Union[int, tuple] = 512,
-                   architecture: str = 'tf_efficientdet_d4'):
+    def make_model(
+        num_classes: int,
+        pretrained_weights: str,
+        image_size: Union[int, tuple] = 512,
+        architecture: str = "tf_efficientdet_d4",
+    ):
         """Constructs the `EfficientDet` model from the provided parameters."""
         # Parse the input arguments.
-        if isinstance(image_size, int): image_size = (image_size, image_size)
-        if pretrained_weights is None or pretrained_weights is False: pretrained_weights = ''
+        if isinstance(image_size, int):
+            image_size = (image_size, image_size)
+        if pretrained_weights is None or pretrained_weights is False:
+            pretrained_weights = ""
 
         # Construct the configuration.
         cfg = get_efficientdet_config(architecture)
-        cfg.update({'image_size': image_size})
+        cfg.update({"image_size": image_size})
 
         # Build the model.
         model_default_pretrained = False
-        if pretrained_weights == 'coco':
+        if pretrained_weights == "coco":
             model_default_pretrained = True
         net = create_model_from_config(
-            cfg, pretrained = model_default_pretrained,
-            num_classes = num_classes)
+            cfg, pretrained=model_default_pretrained, num_classes=num_classes
+        )
 
         # Load the pretrained weights if they are provided.
         if os.path.exists(pretrained_weights):
             # Auto-inference the number of classes from the state dict.
-            state = torch.load(pretrained_weights, map_location = 'cpu')
-            weight_key = [i for i in state.keys() if 'class_net.predict.conv_pw.weight' in i][0]
+            state = torch.load(pretrained_weights, map_location="cpu")
+            weight_key = [
+                i for i in state.keys() if "class_net.predict.conv_pw.weight" in i
+            ][0]
             pretrained_num_classes = int(state[weight_key].shape[0] / 9)
 
             # Load the pretrained weights.
-            net.reset_head(num_classes = pretrained_num_classes)
+            net.reset_head(num_classes=pretrained_num_classes)
             net.load_state_dict(state)
 
             # Restore the number of classes.
             if num_classes != pretrained_num_classes:
-                net.reset_head(num_classes = num_classes)
+                net.reset_head(num_classes=num_classes)
 
         # Return the network.
         return DetBenchTrain(net)
@@ -105,7 +114,9 @@ def _rescale_bboxes_xyxy(predicted_bboxes, image_sizes):
             if len(bboxes) > 0:
                 # Re-scale the bounding box to the appropriate format.
                 scale_ratio = [h / 512, w / 512, h / 512, w / 512]
-                scaled = (np.array(bboxes.detach().cpu()) * scale_ratio).astype(np.int32)
+                scaled = (np.array(bboxes.detach().cpu()) * scale_ratio).astype(
+                    np.int32
+                )
 
                 # Convert the Pascal-VOC (yxyx) format to COCO (xywh).
                 y, x = scaled[:, 0], scaled[:, 1]
@@ -118,7 +129,7 @@ def _rescale_bboxes_xyxy(predicted_bboxes, image_sizes):
         return scaled_boxes
 
     def configure_optimizers(self):
-        return torch.optim.Adam(self.model.parameters(), lr = self.lr)
+        return torch.optim.Adam(self.model.parameters(), lr=self.lr)
 
     def training_step(self, batch, batch_idx):
         # Run a forward pass through the model.
@@ -126,13 +137,29 @@ def training_step(self, batch, batch_idx):
         losses = self.model(images, annotations)
 
         # Calculate and log losses.
-        self.log("train_loss", losses["loss"], on_step = True,
-                 on_epoch = True, prog_bar = True, logger = True)
-        self.log("train_class_loss", losses["class_loss"],
-                 on_step = True, on_epoch = True, logger = True)
-        self.log("train_box_loss", losses["box_loss"], on_step = True,
-                 on_epoch = True, logger = True)
-        return losses['loss']
+        self.log(
+            "train_loss",
+            losses["loss"],
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+        )
+        self.log(
+            "train_class_loss",
+            losses["class_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+        )
+        self.log(
+            "train_box_loss",
+            losses["box_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+        )
+        return losses["loss"]
 
     @torch.no_grad()
     def validation_step(self, batch, batch_idx):
@@ -142,25 +169,51 @@ def validation_step(self, batch, batch_idx):
 
         # Calculate the mean average precision.
         if self._sanity_check_passed:
-            boxes, confidences, labels = self._process_detections(self._to_out(detections))
+            boxes, confidences, labels = self._process_detections(
+                self._to_out(detections)
+            )
             boxes = self._rescale_bboxes(boxes, [[512, 512]] * len(images))
-            annotations['bbox'] = self._rescale_bboxes_xyxy(
-                annotations['bbox'], [[512, 512, ]] * len(images))
+            annotations["bbox"] = self._rescale_bboxes_xyxy(
+                annotations["bbox"],
+                [
+                    [
+                        512,
+                        512,
+                    ]
+                ]
+                * len(images),
+            )
 
             for pred_box, pred_label, pred_conf, true_box, true_label in zip(
-                    boxes, labels, confidences, annotations['bbox'], annotations['cls']):
-                metric_update_values = \
-                    dict(boxes = self._to_out(torch.tensor(pred_box, dtype = torch.float32)),
-                         labels = self._to_out(torch.tensor(pred_label, dtype = torch.int32)),
-                         scores = self._to_out(torch.tensor(pred_conf))), \
-                    dict(boxes = self._to_out(torch.tensor(true_box, dtype = torch.float32)),
-                         labels = self._to_out(torch.tensor(true_label, dtype = torch.int32)))
+                boxes, labels, confidences, annotations["bbox"], annotations["cls"]
+            ):
+                metric_update_values = (
+                    dict(
+                        boxes=self._to_out(torch.tensor(pred_box, dtype=torch.float32)),
+                        labels=self._to_out(
+                            torch.tensor(pred_label, dtype=torch.int32)
+                        ),
+                        scores=self._to_out(torch.tensor(pred_conf)),
+                    ),
+                    dict(
+                        boxes=self._to_out(torch.tensor(true_box, dtype=torch.float32)),
+                        labels=self._to_out(
+                            torch.tensor(true_label, dtype=torch.int32)
+                        ),
+                    ),
+                )
                 self.map.update(*metric_update_values)
 
                 # Log the MAP values.
                 map_ = self.map.compute().detach().cpu().numpy().item()
-                self.log("map", map_, prog_bar = True,
-                         on_epoch = True, logger = True, sync_dist = True)
+                self.log(
+                    "map",
+                    map_,
+                    prog_bar=True,
+                    on_epoch=True,
+                    logger=True,
+                    sync_dist=True,
+                )
 
         batch_predictions = {
             "predictions": detections,
@@ -172,16 +225,33 @@ def validation_step(self, batch, batch_idx):
             "box_loss": outputs["box_loss"].detach(),
         }
 
-        self.log("valid_loss", outputs["loss"], on_step = True, on_epoch = True,
-                 prog_bar = True, logger = True, sync_dist = True)
-        self.log("valid_class_loss", logging_losses["class_loss"],
-                 on_step = True, on_epoch = True,
-                 logger = True, sync_dist = True)
-        self.log("valid_box_loss", logging_losses["box_loss"],
-                 on_step = True, on_epoch = True,
-                 logger = True, sync_dist = True)
-
-        return {'loss': outputs["loss"], 'batch_predictions': batch_predictions}
+        self.log(
+            "valid_loss",
+            outputs["loss"],
+            on_step=True,
+            on_epoch=True,
+            prog_bar=True,
+            logger=True,
+            sync_dist=True,
+        )
+        self.log(
+            "valid_class_loss",
+            logging_losses["class_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+            sync_dist=True,
+        )
+        self.log(
+            "valid_box_loss",
+            logging_losses["box_loss"],
+            on_step=True,
+            on_epoch=True,
+            logger=True,
+            sync_dist=True,
+        )
+
+        return {"loss": outputs["loss"], "batch_predictions": batch_predictions}
 
     def on_validation_epoch_end(self) -> None:
         """Log mean average precision at the end of each epoch."""
@@ -191,16 +261,20 @@ def on_validation_epoch_end(self) -> None:
             return
 
         # Compute the mean average precision and reset it.
-        if hasattr(self, 'map'):
+        if hasattr(self, "map"):
             map_ = self.map.compute().detach().cpu().numpy().item()
-            self.log("map_epoch", map_, prog_bar = True,
-                     on_epoch = True, logger = True, sync_dist = True)
+            self.log(
+                "map_epoch",
+                map_,
+                prog_bar=True,
+                on_epoch=True,
+                logger=True,
+                sync_dist=True,
+            )
             self.map.reset()
 
     def get_progress_bar_dict(self) -> dict:
         """Remove the `v_num` from the bar; it takes away valuable space."""
         p_bar = super(DetectionTrainingModel, self).get_progress_bar_dict()
-        p_bar.pop('v_num', None)
+        p_bar.pop("v_num", None)
         return p_bar
-
-
diff --git a/experiments/benchmarking/experiment.py b/experiments/benchmarking/experiment.py
index fafc2c42..3ef61401 100644
--- a/experiments/benchmarking/experiment.py
+++ b/experiments/benchmarking/experiment.py
@@ -19,13 +19,9 @@
 from pytorch_lightning.loggers import WandbLogger
 
 import agml
-from experiments.benchmarking.detection_data import (
-    build_loader, TransformApplier, EfficientDetDataModule
-)
-from experiments.benchmarking.detection_modeling import (
-    DetectionTrainingModel
-)
 from agml.models.training_resources.tools import gpus
+from experiments.benchmarking.detection_data import EfficientDetDataModule, TransformApplier, build_loader
+from experiments.benchmarking.detection_modeling import DetectionTrainingModel
 
 
 class DetectionExperiment(object):
@@ -36,77 +32,84 @@ def __init__(self, parameters):
 
     def _initialize_experiment(self, params: dict):
         # Get the datasets for which the model is being trained.
-        datasets = params['dataset']
+        datasets = params["dataset"]
         for dataset in datasets:
-            if dataset not in agml.data.public_data_sources(
-                    ml_task = 'object_detection'):
+            if dataset not in agml.data.public_data_sources(ml_task="object_detection"):
                 raise ValueError(
                     f"The provided dataset '{dataset}' is not a valid "
-                    f"object detection dataset in AgML. Try another one.")
+                    f"object detection dataset in AgML. Try another one."
+                )
 
         # Construct the object detection loader.
-        self._loader = build_loader(dataset = datasets,
-                                    batch_size = params.get('batch_size', 4))
+        self._loader = build_loader(
+            dataset=datasets, batch_size=params.get("batch_size", 4)
+        )
 
         # If the user wants to generalize detections, generalize.
-        if params.get('generalize_detections', False):
+        if params.get("generalize_detections", False):
             self._loader.generalize_class_detections()
 
         # Parse the loader for a loader experiment.
         self._parse_loader(params)
 
         # Construct the checkpoint and log directory.
-        experiment_name = params.get('name', None)
-        experiment_dir_default = params.get('experiment_dir', None)
+        experiment_name = params.get("name", None)
+        experiment_dir_default = params.get("experiment_dir", None)
         if experiment_dir_default is None:
             if experiment_name is None:
-                raise ValueError("Expected either the experiment name or save directory.")
-            if os.path.exists('/data2'):
+                raise ValueError(
+                    "Expected either the experiment name or save directory."
+                )
+            if os.path.exists("/data2"):
                 experiment_dir = os.path.join(
-                    '/data2/amnjoshi/experiments', experiment_name)
+                    "/data2/amnjoshi/experiments", experiment_name
+                )
             else:
-                experiment_dir = os.path.join('../training_resources', experiment_name)
+                experiment_dir = os.path.join("../training_resources", experiment_name)
         else:
             experiment_dir = experiment_dir_default
-        os.makedirs(experiment_dir, exist_ok = True)
+        os.makedirs(experiment_dir, exist_ok=True)
         self._experiment_dir = experiment_dir
         if experiment_name is None:
             experiment_name = os.path.basename(experiment_dir)
 
         # Initialize the model.
-        num_classes = params.get('num_classes', None)
+        num_classes = params.get("num_classes", None)
         if num_classes is None:
             num_classes = self._loader.num_classes
         self._model = DetectionTrainingModel(
-            num_classes = num_classes,
-            pretrained_weights = params.get('pretrained_weights', False),
-            confidence_threshold = params.get('confidence_threshold', 0.3),
-            learning_rate = params.get('learning_rate', 0.0002),
-            wbf_iou_threshold = params.get('wbf_iou_threshold', 0.44))
+            num_classes=num_classes,
+            pretrained_weights=params.get("pretrained_weights", False),
+            confidence_threshold=params.get("confidence_threshold", 0.3),
+            learning_rate=params.get("learning_rate", 0.0002),
+            wbf_iou_threshold=params.get("wbf_iou_threshold", 0.44),
+        )
 
         # Build the loggers.
-        loggers = self._parse_logger(experiment_name = experiment_name,
-                                     experiment_dir = experiment_dir)
+        loggers = self._parse_logger(
+            experiment_name=experiment_name, experiment_dir=experiment_dir
+        )
 
         # Construct the `Trainer` with the model.
-        self._trainer = Trainer(logger = loggers, gpus = gpus(None),
-                                max_epochs = params.get('epochs', 25))
+        self._trainer = Trainer(
+            logger=loggers, gpus=gpus(None), max_epochs=params.get("epochs", 25)
+        )
 
     def _parse_loader(self, params):
         """Can be overridden by a subclass for data experiments."""
         # Parse augmentations for an augmentations experiment.
-        augmentations = self._parse_augmentations(
-            params.get('augmentations', None))
+        augmentations = self._parse_augmentations(params.get("augmentations", None))
 
         # Construct the data module.
         self._data_module = EfficientDetDataModule(
-            loader = self._loader,
-            augmentation = augmentations,
-            num_workers = params.get('num_workers', 8))
+            loader=self._loader,
+            augmentation=augmentations,
+            num_workers=params.get("num_workers", 8),
+        )
 
         return self._loader
 
-    def _parse_augmentations(self, augmentations, **kwargs): # noqa
+    def _parse_augmentations(self, augmentations, **kwargs):  # noqa
         """Can be overridden by a subclass to run an augmentation experiment."""
         return TransformApplier(augmentations)
 
@@ -123,18 +126,16 @@ def val_loader(self):
     def _parse_logger(self, *args, **kwargs):
         """Can be overridden by a subclass to return a configured logger."""
         return [
-            WandbLogger(name = kwargs['experiment_name'],
-                        save_dir = kwargs['experiment_dir'])
+            WandbLogger(
+                name=kwargs["experiment_name"], save_dir=kwargs["experiment_dir"]
+            )
         ]
 
     def train(self):
         """Train the model."""
-        self._trainer.fit(self._model,
-                          self._data_module)
-
-        torch.save(self._model.state_dict(),
-                   os.path.join(self._experiment_dir, 'final_model.pth'))
-
-
-
+        self._trainer.fit(self._model, self._data_module)
 
+        torch.save(
+            self._model.state_dict(),
+            os.path.join(self._experiment_dir, "final_model.pth"),
+        )
diff --git a/experiments/benchmarking/finetune_evaluation.py b/experiments/benchmarking/finetune_evaluation.py
index 85cc723c..e2a4edbf 100644
--- a/experiments/benchmarking/finetune_evaluation.py
+++ b/experiments/benchmarking/finetune_evaluation.py
@@ -16,34 +16,28 @@
 import pickle
 
 import numpy as np
-
-import torch
 import pytorch_lightning as pl
-
-from detection_lightning import (
-    EfficientDetModel, EfficientDetDataModule, AgMLDatasetAdaptor
-)
+import torch
+from detection_lightning import AgMLDatasetAdaptor, EfficientDetDataModule, EfficientDetModel
 from mean_average_precision_torch import MeanAveragePrecision
 from pytorch_lightning.loggers import TensorBoardLogger
-
-import agml
-
-from tools import gpus, checkpoint_dir
+from tools import checkpoint_dir, gpus
 from tqdm import tqdm
 
+import agml
 
 FINETUNE_EPOCHS = 5
-EVAL_CLASSES = ['orange', 'apple', 'mango', 'capsicum']
+EVAL_CLASSES = ["orange", "apple", "mango", "capsicum"]
 EVAL_QUANTITIES = [6, 12, 14, 15, 16, 18, 20, 21, 23, 24, 30, 36, 42]
 print("Eval splits:", EVAL_QUANTITIES)
-PRETRAINED_PATH = '/data2/amnjoshi/amg/checkpoints/model_state.pth'
-BASE = '/data2/amnjoshi/finetune'
+PRETRAINED_PATH = "/data2/amnjoshi/amg/checkpoints/model_state.pth"
+BASE = "/data2/amnjoshi/finetune"
 
 
 def generate_splits():
     # Generate the base loader.
     pl.seed_everything(2499751)
-    loader = agml.data.AgMLDataLoader('fruit_detection_worldwide')
+    loader = agml.data.AgMLDataLoader("fruit_detection_worldwide")
 
     # Create the new loaders for each of the classes.
     cls_quant_loaders = {}
@@ -52,10 +46,10 @@ def generate_splits():
         # will be selected, and then another pool of 15 which will be used
         # purely for testing the mean average precision.
         cls_loader = loader.take_class(cls).take_random(42 + 15)
-        cls_loader.split(train = 42, test = 15)
+        cls_loader.split(train=42, test=15)
         pool_loader = cls_loader.train_data
         test_loader = cls_loader.test_data
-        quant_loaders = {'test': test_loader}
+        quant_loaders = {"test": test_loader}
 
         # Starting from 35, we pool a loader with 35 images. Then we take
         # a pool of 30 images from the 35, then 25 from the 30, and so on
@@ -67,42 +61,46 @@ def generate_splits():
     return cls_quant_loaders
 
 
-def train(cls, loader, save_dir, epochs, overwrite = False):
+def train(cls, loader, save_dir, epochs, overwrite=False):
     """Constructs the training loop and trains a model."""
     dataset = loader.name
     save_dir = checkpoint_dir(save_dir, dataset)
-    log_dir = os.path.join(save_dir, 'logs')
+    log_dir = os.path.join(save_dir, "logs")
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Create the loggers.
-    loggers = [
-        TensorBoardLogger(log_dir)
-    ]
+    loggers = [TensorBoardLogger(log_dir)]
 
     # Construct the data.
     dm = EfficientDetDataModule(
-        train_dataset_adaptor = AgMLDatasetAdaptor(loader.train_data),
-        validation_dataset_adaptor = AgMLDatasetAdaptor(loader.val_data),
-        num_workers = 12, batch_size = 1)
+        train_dataset_adaptor=AgMLDatasetAdaptor(loader.train_data),
+        validation_dataset_adaptor=AgMLDatasetAdaptor(loader.val_data),
+        num_workers=12,
+        batch_size=1,
+    )
 
     # Construct the model.
     model = EfficientDetModel(
-        num_classes = loader.num_classes,
-        architecture = 'tf_efficientdet_d4',
-        validation_dataset_adaptor = loader.val_data)
-    model.load_state_dict(torch.load(PRETRAINED_PATH, map_location = 'cpu'))
+        num_classes=loader.num_classes,
+        architecture="tf_efficientdet_d4",
+        validation_dataset_adaptor=loader.val_data,
+    )
+    model.load_state_dict(torch.load(PRETRAINED_PATH, map_location="cpu"))
 
     # Create the trainer and train the model.
-    msg = f"Finetuning class {cls} of size {len(loader.train_data)} for {epochs} epochs!"
+    msg = (
+        f"Finetuning class {cls} of size {len(loader.train_data)} for {epochs} epochs!"
+    )
     print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
-    trainer = pl.Trainer(
-        max_epochs = FINETUNE_EPOCHS, gpus = gpus(None), logger = loggers)
+    trainer = pl.Trainer(max_epochs=FINETUNE_EPOCHS, gpus=gpus(None), logger=loggers)
     trainer.fit(model, dm)
 
     # Return the model state.
@@ -111,27 +109,31 @@ def train(cls, loader, save_dir, epochs, overwrite = False):
 
 def run_evaluation(model, loader) -> dict:
     """Runs evaluation for mAP @ [0.5,0.95]."""
-    iou_thresholds = np.linspace(
-        0.5, 0.95, int(np.round((0.95 - .5) / .05) + 1))
+    iou_thresholds = np.linspace(0.5, 0.95, int(np.round((0.95 - 0.5) / 0.05) + 1))
 
     # Create the adaptor and load the test dataset.
     ds = AgMLDatasetAdaptor(loader)
 
     # Create the metric.
-    ma = MeanAveragePrecision(num_classes = loader.num_classes)
+    ma = MeanAveragePrecision(num_classes=loader.num_classes)
 
     # Run inference for all of the images in the test dataset.
-    for i in tqdm(range(len(ds)), leave = False, desc = "Running mAP Evaluation"):
+    for i in tqdm(range(len(ds)), leave=False, desc="Running mAP Evaluation"):
         image, bboxes, labels, _ = ds.get_image_and_labels_by_idx(i)
         pred_boxes, pred_labels, pred_conf = model.predict([image])
         pred_boxes = np.squeeze(pred_boxes)
         ma.update([pred_boxes, pred_labels, pred_conf], [bboxes, labels])
 
     # Compute the mAP for all of the thresholds.
-    map_values = {f'map@{round(float(thresh), 2)}':
-                      ma.compute(thresh).detach().cpu().numpy().item()
-                  for thresh in iou_thresholds}
-    map_values['map@[0.5,0.95]'] = np.mean(list(map_values.values()))
+    map_values = {
+        f"map@{round(float(thresh), 2)}": ma.compute(thresh)
+        .detach()
+        .cpu()
+        .numpy()
+        .item()
+        for thresh in iou_thresholds
+    }
+    map_values["map@[0.5,0.95]"] = np.mean(list(map_values.values()))
     return map_values
 
 
@@ -149,21 +151,21 @@ def train_all():
             results[cls] = {}
             nice_print_results[cls] = {}
         cls_path = os.path.join(BASE, cls)
-        test_loader = splits[cls]['test']
+        test_loader = splits[cls]["test"]
         for quant in EVAL_QUANTITIES:
-            quant_path = os.path.join(cls_path, f'n-{quant}')
-            os.makedirs(quant_path, exist_ok = True)
+            quant_path = os.path.join(cls_path, f"n-{quant}")
+            os.makedirs(quant_path, exist_ok=True)
 
             # Get the loader and split it accordingly.
             loader = splits[cls][quant]
             train_q, val_q = int(5 * (quant / 6)), quant // 6
             if train_q + val_q < len(loader):
                 val_q = len(loader) - train_q
-            loader.split(train = train_q, val = val_q)
+            loader.split(train=train_q, val=val_q)
 
             # Train the model.
             try:
-                model = train(cls, loader = loader, save_dir = quant_path)
+                model = train(cls, loader=loader, save_dir=quant_path)
             except KeyboardInterrupt:
                 raise ValueError
 
@@ -171,17 +173,18 @@ def train_all():
             model.eval()
             eval_dict = run_evaluation(model, test_loader)
             results[cls][train_q] = eval_dict
-            nice_print_results[cls][train_q] = eval_dict['map@[0.5,0.95]']
+            nice_print_results[cls][train_q] = eval_dict["map@[0.5,0.95]"]
             print("\n", eval_dict, "\n")
 
     # Save all of the results.
     from pprint import pprint
+
     print("\n\nRESULTS:\n")
     pprint(nice_print_results)
 
-    with open(os.path.join(BASE, 'results.pickle'), 'wb') as f:
+    with open(os.path.join(BASE, "results.pickle"), "wb") as f:
         pickle.dump(results, f)
 
 
-if __name__ == '__main__':
-    train_all()
\ No newline at end of file
+if __name__ == "__main__":
+    train_all()
diff --git a/experiments/benchmarking/map_evaluation.py b/experiments/benchmarking/map_evaluation.py
index 0da761d8..f68ce11b 100644
--- a/experiments/benchmarking/map_evaluation.py
+++ b/experiments/benchmarking/map_evaluation.py
@@ -1,6 +1,5 @@
-import torch
 import numpy as np
-
+import torch
 from tqdm import tqdm
 
 
@@ -26,11 +25,12 @@ def _add_truth_scores_to_annotations(annotations):
         a[idx] = [*prior, 1.0, *after]
 
 
-import torch
 from collections import Counter
 
+import torch
+
 
-def intersection_over_union(boxes_preds, boxes_labels, box_format = "midpoint"):
+def intersection_over_union(boxes_preds, boxes_labels, box_format="midpoint"):
     """
     Calculates intersection over union
     Parameters:
@@ -79,8 +79,12 @@ def intersection_over_union(boxes_preds, boxes_labels, box_format = "midpoint"):
 
 
 def mean_average_precision(
-        pred_boxes, true_boxes, iou_threshold = 0.5,
-        box_format = "midpoint", num_classes = 20, use_bar = False
+    pred_boxes,
+    true_boxes,
+    iou_threshold=0.5,
+    box_format="midpoint",
+    num_classes=20,
+    use_bar=False,
 ):
     """
     Calculates mean average precision
@@ -108,7 +112,7 @@ def mean_average_precision(
 
     classes = range(num_classes)
     if use_bar:
-        classes = tqdm(classes, leave = False)
+        classes = tqdm(classes, leave=False)
 
     for c in classes:
         detections = []
@@ -139,7 +143,7 @@ def mean_average_precision(
             amount_bboxes[key] = torch.zeros(val)
 
         # sort by box probabilities which is index 2
-        detections.sort(key = lambda x: x[2], reverse = True)
+        detections.sort(key=lambda x: x[2], reverse=True)
         TP = torch.zeros((len(detections)))
         FP = torch.zeros((len(detections)))
         total_true_bboxes = len(ground_truths)
@@ -162,7 +166,7 @@ def mean_average_precision(
                 iou = intersection_over_union(
                     torch.tensor(detection[3:]),
                     torch.tensor(gt[3:]),
-                    box_format = box_format,
+                    box_format=box_format,
                 )
 
                 if iou > best_iou:
@@ -182,8 +186,8 @@ def mean_average_precision(
             else:
                 FP[detection_idx] = 1
 
-        TP_cumsum = torch.cumsum(TP, dim = 0)
-        FP_cumsum = torch.cumsum(FP, dim = 0)
+        TP_cumsum = torch.cumsum(TP, dim=0)
+        FP_cumsum = torch.cumsum(FP, dim=0)
         recalls = TP_cumsum / (total_true_bboxes + epsilon)
         precisions = TP_cumsum / (TP_cumsum + FP_cumsum + epsilon)
         precisions = torch.cat((torch.tensor([1]), precisions))
@@ -199,7 +203,7 @@ def mean_average_precision(
 class MeanAveragePrecision(object):
     """Stores and calculates the mean average precision over data."""
 
-    def __init__(self, num_classes = 1, use_bar = False):
+    def __init__(self, num_classes=1, use_bar=False):
         self._num_classes = num_classes
 
         # Store all of the ground truth and prediction data.
@@ -233,14 +237,16 @@ def update(self, pred_data, gt_data):
         """
         # Get the relevant data from the input arguments.
         if isinstance(pred_data, dict):
-            pred_boxes, pred_labels, pred_scores = \
-                pred_data['boxes'], pred_data['labels'], pred_data['scores']
+            pred_boxes, pred_labels, pred_scores = (
+                pred_data["boxes"],
+                pred_data["labels"],
+                pred_data["scores"],
+            )
         else:
             pred_boxes, pred_labels, pred_scores = pred_data
 
         if isinstance(gt_data, dict):
-            gt_boxes, gt_labels = \
-                gt_data['boxes'], gt_data['labels']
+            gt_boxes, gt_labels = gt_data["boxes"], gt_data["labels"]
         else:
             gt_boxes, gt_labels = gt_data
 
@@ -248,22 +254,23 @@ def update(self, pred_data, gt_data):
         pred_boxes = np.squeeze(pred_boxes)
         pred_labels = np.squeeze(pred_labels)
         pred_scores = np.squeeze(pred_scores)
-        pred_labels, gt_labels, pred_scores = \
-            _scalar_to_array(pred_labels, gt_labels, pred_scores)
+        pred_labels, gt_labels, pred_scores = _scalar_to_array(
+            pred_labels, gt_labels, pred_scores
+        )
         if pred_boxes.ndim == 1:
-            pred_boxes = np.expand_dims(pred_boxes, axis = 0)
+            pred_boxes = np.expand_dims(pred_boxes, axis=0)
         if gt_boxes.ndim == 1:
-            gt_boxes = np.expand_dims(gt_boxes, axis = 0)
+            gt_boxes = np.expand_dims(gt_boxes, axis=0)
 
         # Create the data in the proper format.
         for bbox, label in zip(gt_boxes, gt_labels):
-            self._ground_truth_data.append(
-                [self._num_updates, int(label - 1), *bbox])
+            self._ground_truth_data.append([self._num_updates, int(label - 1), *bbox])
         if pred_boxes.ndim == 1:
-            pred_boxes = np.expand_dims(pred_boxes, axis = 0)
+            pred_boxes = np.expand_dims(pred_boxes, axis=0)
         for bbox, label, score in zip(pred_boxes, pred_labels, pred_scores):
             self._prediction_data.append(
-                [self._num_updates, int(label - 1), score, *bbox])
+                [self._num_updates, int(label - 1), score, *bbox]
+            )
 
         # Increment the update number.
         self._num_updates += 1
@@ -273,14 +280,15 @@ def historical_data(self):
         """Returns historical mAP over past data."""
         return self._prior_maps
 
-    def compute(self, iou_threshold = 0.5):
+    def compute(self, iou_threshold=0.5):
         """Computes the mAP with the data."""
         ap = mean_average_precision(
             self._prediction_data,
             self._ground_truth_data,
-            num_classes = self._num_classes,
-            iou_threshold = iou_threshold,
-            use_bar = self._use_bar)
+            num_classes=self._num_classes,
+            iou_threshold=iou_threshold,
+            use_bar=self._use_bar,
+        )
         self._prior_maps[self._num_updates] = ap
         return ap
 
@@ -291,12 +299,3 @@ def reset(self):
         self._prediction_data = []
         self._ground_truth_data = []
         self._num_updates = 0
-
-
-
-
-
-
-
-
-
diff --git a/experiments/benchmarking/map_evaluation_multiple.py b/experiments/benchmarking/map_evaluation_multiple.py
index ef0b8e8e..62e14250 100644
--- a/experiments/benchmarking/map_evaluation_multiple.py
+++ b/experiments/benchmarking/map_evaluation_multiple.py
@@ -12,20 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
-import glob
 import argparse
+import glob
+import os
 
 import numpy as np
 import pandas as pd
-from tqdm import tqdm
-
-import torch
 import pytorch_lightning as pl
-
-import agml
+import torch
 from detection_lightning import AgMLDatasetAdaptor, EfficientDetModel
 from mean_average_precision_torch import MeanAveragePrecision
+from tqdm import tqdm
+
+import agml
 
 
 def run_evaluation(model, name):
@@ -40,76 +39,84 @@ def run_evaluation(model, name):
 
 def run_evaluation_by_loader(model, loader):
     """Runs evaluation for a class for mAP @ [0.5,0.95]."""
-    iou_thresholds = np.linspace(
-        0.5, 0.95, int(np.round((0.95 - .5) / .05) + 1))
+    iou_thresholds = np.linspace(0.5, 0.95, int(np.round((0.95 - 0.5) / 0.05) + 1))
 
     # Create the adaptor and load the test dataset.
     ds = AgMLDatasetAdaptor(loader.test_data)
 
     # Create the metric.
-    ma = MeanAveragePrecision(num_classes = loader.num_classes)
+    ma = MeanAveragePrecision(num_classes=loader.num_classes)
 
     # Run inference for all of the images in the test dataset.
-    for i in tqdm(range(len(ds)), leave = False):
+    for i in tqdm(range(len(ds)), leave=False):
         image, bboxes, labels, _ = ds.get_image_and_labels_by_idx(i)
         pred_boxes, pred_labels, pred_conf = model.predict([image])
         pred_boxes = np.squeeze(pred_boxes)
         ma.update([pred_boxes, pred_labels, pred_conf], [bboxes, labels])
 
     # Compute the mAP for all of the thresholds.
-    map_values = [ma.compute(thresh).detach().cpu().numpy()
-                  for thresh in iou_thresholds]
+    map_values = [
+        ma.compute(thresh).detach().cpu().numpy() for thresh in iou_thresholds
+    ]
     return np.mean(map_values)
 
 
-def make_checkpoint(name, path = None, num_classes = None):
+def make_checkpoint(name, path=None, num_classes=None):
     """Gets a checkpoint for the model name."""
     model = EfficientDetModel(
-        num_classes = agml.data.source(name).num_classes if num_classes is None else num_classes,
-        architecture = 'tf_efficientdet_d4')
+        num_classes=agml.data.source(name).num_classes
+        if num_classes is None
+        else num_classes,
+        architecture="tf_efficientdet_d4",
+    )
     if path is not None:
-        state = torch.load(path, map_location = 'cpu')
+        state = torch.load(path, map_location="cpu")
         model.load_state_dict(state)
     model.eval().cuda()
     return model
 
 
-def evaluate_different_benchmarks(paths, names, log_file = None):
+def evaluate_different_benchmarks(paths, names, log_file=None):
     """Runs the evaluation for different pretrained weights."""
     print(f"Running mAP evaluation for {paths}.")
 
     # Create the log file.
     if log_file is None:
-        log_file = os.path.join(os.getcwd(), 'map_evaluation.csv')
+        log_file = os.path.join(os.getcwd(), "map_evaluation.csv")
 
     # Run the evaluation.
-    df = pd.DataFrame(columns = names, index = [
-        os.path.basename(os.path.dirname(os.path.dirname(p))) for p in paths])
+    df = pd.DataFrame(
+        columns=names,
+        index=[os.path.basename(os.path.dirname(os.path.dirname(p))) for p in paths],
+    )
     for name in names:
         log_contents = {}
         bar = tqdm(paths)
         from collections import defaultdict
+
         ncs = defaultdict(lambda: 1)
         for path in bar:
-            nc = ncs[os.path.basename(path).split('-')[0]]
-            ckpt = make_checkpoint(name, path = path, num_classes = nc)
+            nc = ncs[os.path.basename(path).split("-")[0]]
+            ckpt = make_checkpoint(name, path=path, num_classes=nc)
             bar.set_description(f"Evaluating {name} @ {path} @ nc = {nc}")
-            if hasattr(name, 'name'):
+            if hasattr(name, "name"):
                 name = name.name
-            log_contents[os.path.basename(os.path.dirname(os.path.dirname(path)))] \
-                = run_evaluation(ckpt, name)
+            log_contents[os.path.basename(os.path.dirname(os.path.dirname(path)))] = (
+                run_evaluation(ckpt, name)
+            )
 
         # Save the results.
         df[name] = log_contents.values()
     df.to_csv(log_file)
 
-def evaluate_per_class(dataset, path = None, log_file = None):
+
+def evaluate_per_class(dataset, path=None, log_file=None):
     """Runs the evaluation for each class in a dataset."""
     print(f"Running mAP evaluation for {dataset}.")
 
     # Create the log file.
     if log_file is None:
-        log_file = os.path.join(os.getcwd(), 'map_evaluation_per_class.csv')
+        log_file = os.path.join(os.getcwd(), "map_evaluation_per_class.csv")
 
     # Construct the super-loader.
     pl.seed_everything(2499751)
@@ -122,9 +129,13 @@ def evaluate_per_class(dataset, path = None, log_file = None):
     for cl in range(agml.data.source(dataset).num_classes):
         cls = cl + 1
         new_loader = loader.take_class(cls)
-        new_loader.split(train = 0.8, val = 0.1, test = 0.1)
-        ckpt = make_checkpoint('grape_detection_californiaday', path = path, num_classes = 1)
-        print(f"Evaluating fruit_detection_worldwide @ class '{loader.num_to_class[cls]}'")
+        new_loader.split(train=0.8, val=0.1, test=0.1)
+        ckpt = make_checkpoint(
+            "grape_detection_californiaday", path=path, num_classes=1
+        )
+        print(
+            f"Evaluating fruit_detection_worldwide @ class '{loader.num_to_class[cls]}'"
+        )
         result = run_evaluation_by_loader(ckpt, new_loader)
 
         # Save the results.
@@ -132,49 +143,61 @@ def evaluate_per_class(dataset, path = None, log_file = None):
     return lit
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--log_file', type = str, default = None,
-        help = "The name of the output log file.")
+        "--log_file", type=str, default=None, help="The name of the output log file."
+    )
     ap.add_argument(
-        '--per-class-for-dataset', action = 'store_true',
-        default = False, help = "Whether to generate benchmarks per class.")
+        "--per-class-for-dataset",
+        action="store_true",
+        default=False,
+        help="Whether to generate benchmarks per class.",
+    )
     args = ap.parse_args()
 
     # Train the model.
     if args.per_class_for_dataset:
         results = []
-        for path_type in [None, '/data2/amnjoshi/detection-models/grape.pth',
-                          '/data2/amnjoshi/detection-models/amg.pth']:
-            results.append(evaluate_per_class(args.dataset[0], path = path_type, log_file = args.log_file))
+        for path_type in [
+            None,
+            "/data2/amnjoshi/detection-models/grape.pth",
+            "/data2/amnjoshi/detection-models/amg.pth",
+        ]:
+            results.append(
+                evaluate_per_class(
+                    args.dataset[0], path=path_type, log_file=args.log_file
+                )
+            )
             print(results)
-        loader = agml.data.AgMLDataLoader('fruit_detection_worldwide')
-        df = pd.DataFrame(columns = loader.classes, index = ['COCO', 'GRAPE', 'AMG'])
-        for result, typ in zip(results, ['COCO', 'GRAPE', 'AMG']):
+        loader = agml.data.AgMLDataLoader("fruit_detection_worldwide")
+        df = pd.DataFrame(columns=loader.classes, index=["COCO", "GRAPE", "AMG"])
+        for result, typ in zip(results, ["COCO", "GRAPE", "AMG"]):
             df.loc[typ] = result
         df.to_csv(args.log_file)
     else:
-        if args.dataset[0] in agml.data.public_data_sources(ml_task = 'object_detection'):
-                datasets = args.dataset[0]
+        if args.dataset[0] in agml.data.public_data_sources(ml_task="object_detection"):
+            datasets = args.dataset[0]
         else:
-            if args.dataset[0] == 'all':
-                datasets = [ds for ds in agml.data.public_data_sources(
-                    ml_task = 'object_detection')]
-            elif args.dataset[0] == 'except':
+            if args.dataset[0] == "all":
+                datasets = [
+                    ds
+                    for ds in agml.data.public_data_sources(ml_task="object_detection")
+                ]
+            elif args.dataset[0] == "except":
                 exclude_datasets = args.dataset[1:]
                 datasets = [
-                    dataset for dataset in agml.data.public_data_sources(
-                        ml_task = 'object_detection')
-                    if dataset.name not in exclude_datasets]
+                    dataset
+                    for dataset in agml.data.public_data_sources(
+                        ml_task="object_detection"
+                    )
+                    if dataset.name not in exclude_datasets
+                ]
             else:
                 datasets = args.dataset
         evaluate_different_benchmarks(
-            glob.glob('/data2/amnjoshi/flood-grape/ejb-cc/**/*.pth', recursive = True),
-            datasets, args.log_file)
-
-
-
-
+            glob.glob("/data2/amnjoshi/flood-grape/ejb-cc/**/*.pth", recursive=True),
+            datasets,
+            args.log_file,
+        )
diff --git a/experiments/benchmarking/mean_average_precision.py b/experiments/benchmarking/mean_average_precision.py
index 2475724a..249f4e35 100644
--- a/experiments/benchmarking/mean_average_precision.py
+++ b/experiments/benchmarking/mean_average_precision.py
@@ -31,7 +31,7 @@ def _add_truth_scores_to_annotations(annotations):
     elements of the form [image_idx, class, x1, y1, x2, y2], and adds
     a dummy `score` element of 1.0 to satisfy the MAP method.
     """
-    a = annotations # short-hand
+    a = annotations  # short-hand
     for idx in range(len(annotations)):
         prior, after = a[idx][:2], a[idx][2:]
         a[idx] = [*prior, 1.0, *after]
@@ -51,17 +51,18 @@ def intersection_over_union(pred_boxes, gt_boxes):
 
     # Find the area of the two boxes and calculate the IoU.
     intersection = (x2 - x1).clip(0, None) * (y2 - y1).clip(0, None)
-    pred_area = abs((pred_boxes[..., 2:3] - pred_boxes[..., 0:1])
-                    * (pred_boxes[..., 3:4] - pred_boxes[..., 1:2]))
-    gt_area = abs((gt_boxes[..., 2:3] - gt_boxes[..., 0:1])
-                    * (gt_boxes[..., 3:4] - gt_boxes[..., 1:2]))
+    pred_area = abs(
+        (pred_boxes[..., 2:3] - pred_boxes[..., 0:1])
+        * (pred_boxes[..., 3:4] - pred_boxes[..., 1:2])
+    )
+    gt_area = abs(
+        (gt_boxes[..., 2:3] - gt_boxes[..., 0:1])
+        * (gt_boxes[..., 3:4] - gt_boxes[..., 1:2])
+    )
     return intersection / (pred_area + gt_area - intersection + 1e-6)
 
 
-def mean_average_precision(pred_boxes,
-                           true_boxes,
-                           num_classes = 1,
-                           iou_threshold = 0.5):
+def mean_average_precision(pred_boxes, true_boxes, num_classes=1, iou_threshold=0.5):
     """Calculates the mean average precision (mAP) of data samples."""
     # Since we modify the input arguments in-place, make a copy so as
     # not to affect the original variables which are passed to this method.
@@ -79,24 +80,22 @@ def mean_average_precision(pred_boxes,
         # Get the corresponding predictions and targets for this class.
         where_pred_box = np.array(pred_boxes)
         where_true_box = np.array(true_boxes)
-        detections = where_pred_box[
-            np.where(where_pred_box[:, 1] == c)[0]].tolist()
-        ground_truths = where_true_box[
-            np.where(where_true_box[:, 1] == c)[0]].tolist()
+        detections = where_pred_box[np.where(where_pred_box[:, 1] == c)[0]].tolist()
+        ground_truths = where_true_box[np.where(where_true_box[:, 1] == c)[0]].tolist()
 
         # Get all of the unique data samples and create a dictionary
         # storing all of the corresponding bounding boxes for each sample.
         training_ids = np.unique(where_true_box[:, 0])
         truth_samples_by_id = {
             idx: where_true_box[np.where(where_true_box[:, 0] == idx)]
-            for idx in training_ids}
+            for idx in training_ids
+        }
 
         # Determine the number of boxes for each of the training samples
         numpy_gt = np.array(ground_truths)
         counts = np.bincount(numpy_gt[:, 0].astype(np.int64))
         indices = np.nonzero(counts)[0]
-        amount_bboxes = {
-             k: np.zeros(v) for k, v in zip(indices, counts)}
+        amount_bboxes = {k: np.zeros(v) for k, v in zip(indices, counts)}
 
         # Sort the boxes by probabilities.
         detections.sort(key=lambda x: x[2], reverse=True)
@@ -115,9 +114,12 @@ def mean_average_precision(pred_boxes,
             ground_truth_img = truth_samples_by_id[int(detection[0])]
 
             # Get the bounding box with the highest IoU.
-            ious = np.array([intersection_over_union(
-                np.array(detection[3:]), np.array(gt[3:]))
-                for gt in ground_truth_img])
+            ious = np.array(
+                [
+                    intersection_over_union(np.array(detection[3:]), np.array(gt[3:]))
+                    for gt in ground_truth_img
+                ]
+            )
             best_iou = np.max(ious)
             best_gt_idx = np.argmax(ious)
 
@@ -137,9 +139,9 @@ def mean_average_precision(pred_boxes,
                 FP[detection_idx] = 1
 
         # Calculate the prediction/recalls and update the array.
-        tp_cumsum = np.cumsum(TP, axis = 0)
+        tp_cumsum = np.cumsum(TP, axis=0)
         recalls = tp_cumsum / (total_true_bboxes + 1e-6)
-        precisions = tp_cumsum / (tp_cumsum + np.cumsum(FP, axis = 0) + 1e-6)
+        precisions = tp_cumsum / (tp_cumsum + np.cumsum(FP, axis=0) + 1e-6)
         precisions = np.concatenate((np.array([1]), precisions))
         recalls = np.concatenate((np.array([0]), recalls))
         average_precisions.append(np.trapz(precisions, recalls))
@@ -150,7 +152,8 @@ def mean_average_precision(pred_boxes,
 
 class MeanAveragePrecision(object):
     """Stores and calculates the mean average precision over data."""
-    def __init__(self, num_classes = 1):
+
+    def __init__(self, num_classes=1):
         self._num_classes = num_classes
 
         # Store all of the ground truth and prediction data.
@@ -181,14 +184,16 @@ def update(self, pred_data, gt_data):
         """
         # Get the relevant data from the input arguments.
         if isinstance(pred_data, dict):
-            pred_boxes, pred_labels, pred_scores = \
-                pred_data['boxes'], pred_data['labels'], pred_data['scores']
+            pred_boxes, pred_labels, pred_scores = (
+                pred_data["boxes"],
+                pred_data["labels"],
+                pred_data["scores"],
+            )
         else:
             pred_boxes, pred_labels, pred_scores = pred_data
 
         if isinstance(gt_data, dict):
-            gt_boxes, gt_labels = \
-                gt_data['boxes'], gt_data['labels']
+            gt_boxes, gt_labels = gt_data["boxes"], gt_data["labels"]
         else:
             gt_boxes, gt_labels = gt_data
 
@@ -196,22 +201,23 @@ def update(self, pred_data, gt_data):
         pred_boxes = np.squeeze(pred_boxes)
         pred_labels = np.squeeze(pred_labels)
         pred_scores = np.squeeze(pred_scores)
-        pred_labels, gt_labels, pred_scores = \
-            _scalar_to_array(pred_labels, gt_labels, pred_scores)
+        pred_labels, gt_labels, pred_scores = _scalar_to_array(
+            pred_labels, gt_labels, pred_scores
+        )
         if pred_boxes.ndim == 1:
-            pred_boxes = np.expand_dims(pred_boxes, axis = 0)
+            pred_boxes = np.expand_dims(pred_boxes, axis=0)
         if gt_boxes.ndim == 1:
-            gt_boxes = np.expand_dims(gt_boxes, axis = 0)
+            gt_boxes = np.expand_dims(gt_boxes, axis=0)
 
         # Create the data in the proper format.
         for bbox, label in zip(gt_boxes, gt_labels):
-            self._ground_truth_data.append(
-                [self._num_updates, int(label - 1), *bbox])
+            self._ground_truth_data.append([self._num_updates, int(label - 1), *bbox])
         if pred_boxes.ndim == 1:
-            pred_boxes = np.expand_dims(pred_boxes, axis = 0)
+            pred_boxes = np.expand_dims(pred_boxes, axis=0)
         for bbox, label, score in zip(pred_boxes, pred_labels, pred_scores):
             self._prediction_data.append(
-                [self._num_updates, int(label - 1), score, *bbox])
+                [self._num_updates, int(label - 1), score, *bbox]
+            )
 
         # Increment the update number.
         self._num_updates += 1
@@ -221,23 +227,13 @@ def historical_data(self):
         """Returns historical mAP over past data."""
         return self._prior_maps
 
-    def compute(self, iou_threshold = 0.5):
+    def compute(self, iou_threshold=0.5):
         """Computes the mAP with the data."""
         ap = mean_average_precision(
             self._prediction_data,
             self._ground_truth_data,
-            num_classes = self._num_classes,
-            iou_threshold = iou_threshold)
+            num_classes=self._num_classes,
+            iou_threshold=iou_threshold,
+        )
         self._prior_maps[self._num_updates] = ap
         return ap
-
-
-
-
-
-
-
-
-
-
-
diff --git a/experiments/benchmarking/mean_average_precision_torch.py b/experiments/benchmarking/mean_average_precision_torch.py
index 0da761d8..f68ce11b 100644
--- a/experiments/benchmarking/mean_average_precision_torch.py
+++ b/experiments/benchmarking/mean_average_precision_torch.py
@@ -1,6 +1,5 @@
-import torch
 import numpy as np
-
+import torch
 from tqdm import tqdm
 
 
@@ -26,11 +25,12 @@ def _add_truth_scores_to_annotations(annotations):
         a[idx] = [*prior, 1.0, *after]
 
 
-import torch
 from collections import Counter
 
+import torch
+
 
-def intersection_over_union(boxes_preds, boxes_labels, box_format = "midpoint"):
+def intersection_over_union(boxes_preds, boxes_labels, box_format="midpoint"):
     """
     Calculates intersection over union
     Parameters:
@@ -79,8 +79,12 @@ def intersection_over_union(boxes_preds, boxes_labels, box_format = "midpoint"):
 
 
 def mean_average_precision(
-        pred_boxes, true_boxes, iou_threshold = 0.5,
-        box_format = "midpoint", num_classes = 20, use_bar = False
+    pred_boxes,
+    true_boxes,
+    iou_threshold=0.5,
+    box_format="midpoint",
+    num_classes=20,
+    use_bar=False,
 ):
     """
     Calculates mean average precision
@@ -108,7 +112,7 @@ def mean_average_precision(
 
     classes = range(num_classes)
     if use_bar:
-        classes = tqdm(classes, leave = False)
+        classes = tqdm(classes, leave=False)
 
     for c in classes:
         detections = []
@@ -139,7 +143,7 @@ def mean_average_precision(
             amount_bboxes[key] = torch.zeros(val)
 
         # sort by box probabilities which is index 2
-        detections.sort(key = lambda x: x[2], reverse = True)
+        detections.sort(key=lambda x: x[2], reverse=True)
         TP = torch.zeros((len(detections)))
         FP = torch.zeros((len(detections)))
         total_true_bboxes = len(ground_truths)
@@ -162,7 +166,7 @@ def mean_average_precision(
                 iou = intersection_over_union(
                     torch.tensor(detection[3:]),
                     torch.tensor(gt[3:]),
-                    box_format = box_format,
+                    box_format=box_format,
                 )
 
                 if iou > best_iou:
@@ -182,8 +186,8 @@ def mean_average_precision(
             else:
                 FP[detection_idx] = 1
 
-        TP_cumsum = torch.cumsum(TP, dim = 0)
-        FP_cumsum = torch.cumsum(FP, dim = 0)
+        TP_cumsum = torch.cumsum(TP, dim=0)
+        FP_cumsum = torch.cumsum(FP, dim=0)
         recalls = TP_cumsum / (total_true_bboxes + epsilon)
         precisions = TP_cumsum / (TP_cumsum + FP_cumsum + epsilon)
         precisions = torch.cat((torch.tensor([1]), precisions))
@@ -199,7 +203,7 @@ def mean_average_precision(
 class MeanAveragePrecision(object):
     """Stores and calculates the mean average precision over data."""
 
-    def __init__(self, num_classes = 1, use_bar = False):
+    def __init__(self, num_classes=1, use_bar=False):
         self._num_classes = num_classes
 
         # Store all of the ground truth and prediction data.
@@ -233,14 +237,16 @@ def update(self, pred_data, gt_data):
         """
         # Get the relevant data from the input arguments.
         if isinstance(pred_data, dict):
-            pred_boxes, pred_labels, pred_scores = \
-                pred_data['boxes'], pred_data['labels'], pred_data['scores']
+            pred_boxes, pred_labels, pred_scores = (
+                pred_data["boxes"],
+                pred_data["labels"],
+                pred_data["scores"],
+            )
         else:
             pred_boxes, pred_labels, pred_scores = pred_data
 
         if isinstance(gt_data, dict):
-            gt_boxes, gt_labels = \
-                gt_data['boxes'], gt_data['labels']
+            gt_boxes, gt_labels = gt_data["boxes"], gt_data["labels"]
         else:
             gt_boxes, gt_labels = gt_data
 
@@ -248,22 +254,23 @@ def update(self, pred_data, gt_data):
         pred_boxes = np.squeeze(pred_boxes)
         pred_labels = np.squeeze(pred_labels)
         pred_scores = np.squeeze(pred_scores)
-        pred_labels, gt_labels, pred_scores = \
-            _scalar_to_array(pred_labels, gt_labels, pred_scores)
+        pred_labels, gt_labels, pred_scores = _scalar_to_array(
+            pred_labels, gt_labels, pred_scores
+        )
         if pred_boxes.ndim == 1:
-            pred_boxes = np.expand_dims(pred_boxes, axis = 0)
+            pred_boxes = np.expand_dims(pred_boxes, axis=0)
         if gt_boxes.ndim == 1:
-            gt_boxes = np.expand_dims(gt_boxes, axis = 0)
+            gt_boxes = np.expand_dims(gt_boxes, axis=0)
 
         # Create the data in the proper format.
         for bbox, label in zip(gt_boxes, gt_labels):
-            self._ground_truth_data.append(
-                [self._num_updates, int(label - 1), *bbox])
+            self._ground_truth_data.append([self._num_updates, int(label - 1), *bbox])
         if pred_boxes.ndim == 1:
-            pred_boxes = np.expand_dims(pred_boxes, axis = 0)
+            pred_boxes = np.expand_dims(pred_boxes, axis=0)
         for bbox, label, score in zip(pred_boxes, pred_labels, pred_scores):
             self._prediction_data.append(
-                [self._num_updates, int(label - 1), score, *bbox])
+                [self._num_updates, int(label - 1), score, *bbox]
+            )
 
         # Increment the update number.
         self._num_updates += 1
@@ -273,14 +280,15 @@ def historical_data(self):
         """Returns historical mAP over past data."""
         return self._prior_maps
 
-    def compute(self, iou_threshold = 0.5):
+    def compute(self, iou_threshold=0.5):
         """Computes the mAP with the data."""
         ap = mean_average_precision(
             self._prediction_data,
             self._ground_truth_data,
-            num_classes = self._num_classes,
-            iou_threshold = iou_threshold,
-            use_bar = self._use_bar)
+            num_classes=self._num_classes,
+            iou_threshold=iou_threshold,
+            use_bar=self._use_bar,
+        )
         self._prior_maps[self._num_updates] = ap
         return ap
 
@@ -291,12 +299,3 @@ def reset(self):
         self._prediction_data = []
         self._ground_truth_data = []
         self._num_updates = 0
-
-
-
-
-
-
-
-
-
diff --git a/experiments/benchmarking/miou_evaluation.py b/experiments/benchmarking/miou_evaluation.py
index eb647633..78abfac8 100644
--- a/experiments/benchmarking/miou_evaluation.py
+++ b/experiments/benchmarking/miou_evaluation.py
@@ -12,22 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import os
 
 import pandas as pd
-from tqdm import tqdm
-
-import torch
 import pytorch_lightning as pl
-
-import agml
-from torchmetrics import IoU
+import torch
 from segmentation_lightning import SegmentationBenchmark
+from torchmetrics import IoU
+from tqdm import tqdm
 
+import agml
 
 # Define device.
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 
 def run_evaluation(model, name):
@@ -35,18 +33,18 @@ def run_evaluation(model, name):
     # Load the test dataset.
     pl.seed_everything(2499751)
     loader = agml.data.AgMLDataLoader(name)
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
-    loader.batch(batch_size = 2)
+    loader.split(train=0.8, val=0.1, test=0.1)
+    loader.batch(batch_size=2)
     loader.resize_images((512, 512))
-    loader.normalize_images('imagenet')
+    loader.normalize_images("imagenet")
     loader.mask_to_channel_basis()
     ds = loader.test_data.as_torch_dataset()
 
     # Create the metric.
-    iou = IoU(num_classes = ds.num_classes + 1)
+    iou = IoU(num_classes=ds.num_classes + 1)
 
     # Run inference for all of the images in the test dataset.
-    for i in tqdm(range(len(ds)), leave = False):
+    for i in tqdm(range(len(ds)), leave=False):
         image, annotation = ds[i]
         y_pred = model(image.to(device)).float().squeeze()
         iou(y_pred.detach().cpu(), annotation.int().cpu())
@@ -59,21 +57,22 @@ def run_evaluation(model, name):
 def make_checkpoint(name):
     """Gets a checkpoint for the model name."""
     ckpt_path = os.path.join(
-        "/data2/amnjoshi/final/segmentation_checkpoints", name, "final_model.pth")
-    state = torch.load(ckpt_path, map_location = 'cpu')
-    model = SegmentationBenchmark(dataset = name)
+        "/data2/amnjoshi/final/segmentation_checkpoints", name, "final_model.pth"
+    )
+    state = torch.load(ckpt_path, map_location="cpu")
+    model = SegmentationBenchmark(dataset=name)
     model.load_state_dict(state)
     model.eval().to(device)
     return model
 
 
-def evaluate(names, log_file = None):
+def evaluate(names, log_file=None):
     """Runs the evaluation and saves results to a file."""
     print(f"Running mIoU evaluation for {names}.")
 
     # Create the log file.
     if log_file is None:
-        log_file = os.path.join(os.getcwd(), 'miou_evaluation.csv')
+        log_file = os.path.join(os.getcwd(), "miou_evaluation.csv")
 
     # Run the evaluation.
     log_contents = {}
@@ -81,43 +80,45 @@ def evaluate(names, log_file = None):
     for name in bar:
         ckpt = make_checkpoint(name)
         bar.set_description(f"Evaluating {name}")
-        if hasattr(name, 'name'):
+        if hasattr(name, "name"):
             name = name.name
         log_contents[name] = run_evaluation(ckpt, name)
 
     # Save the results.
-    df = pd.DataFrame(columns = ('name', 'miou'))
+    df = pd.DataFrame(columns=("name", "miou"))
     for name, value in log_contents.items():
         df.loc[len(df.index)] = [name, value]
     df.to_csv(log_file)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--log_file', type = str, default = None,
-        help = "The name of the output log file.")
+        "--log_file", type=str, default=None, help="The name of the output log file."
+    )
     args = ap.parse_args()
 
     # Train the model.
-    if args.dataset[0] in agml.data.public_data_sources(ml_task = 'semantic_segmentation'):
+    if args.dataset[0] in agml.data.public_data_sources(
+        ml_task="semantic_segmentation"
+    ):
         datasets = args.dataset[0]
     else:
-        if args.dataset[0] == 'all':
-            datasets = [ds for ds in agml.data.public_data_sources(
-                ml_task = 'semantic_segmentation')]
-        elif args.dataset[0] == 'except':
+        if args.dataset[0] == "all":
+            datasets = [
+                ds
+                for ds in agml.data.public_data_sources(ml_task="semantic_segmentation")
+            ]
+        elif args.dataset[0] == "except":
             exclude_datasets = args.dataset[1:]
             datasets = [
-                dataset for dataset in agml.data.public_data_sources(
-                    ml_task = 'semantic_segmentation')
-                if dataset.name not in exclude_datasets]
+                dataset
+                for dataset in agml.data.public_data_sources(
+                    ml_task="semantic_segmentation"
+                )
+                if dataset.name not in exclude_datasets
+            ]
         else:
             datasets = args.dataset
     evaluate(datasets, args.log_file)
-
-
-
-
diff --git a/experiments/benchmarking/segmentation_lightning.py b/experiments/benchmarking/segmentation_lightning.py
index 89c61d82..71e8543d 100644
--- a/experiments/benchmarking/segmentation_lightning.py
+++ b/experiments/benchmarking/segmentation_lightning.py
@@ -12,22 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import os
 
+import albumentations as A
+import pytorch_lightning as pl
 import torch
 import torch.nn as nn
-import pytorch_lightning as pl
-from pytorch_lightning.loggers import WandbLogger
+import wandb
 from pytorch_lightning.callbacks import LearningRateMonitor
+from pytorch_lightning.loggers import WandbLogger
+from tools import MetricLogger, checkpoint_dir, gpus
 from torchmetrics import IoU
 from torchvision.models.segmentation import deeplabv3_resnet50
 
 import agml
-import wandb
-import albumentations as A
-
-from tools import gpus, checkpoint_dir, MetricLogger
 
 
 class DeepLabV3Transfer(nn.Module):
@@ -36,33 +35,32 @@ class DeepLabV3Transfer(nn.Module):
     This is the base benchmarking model for semantic segmentation,
     using the DeepLabV3 model with a ResNet50 backbone.
     """
-    def __init__(self, num_classes, pretrained = True, freeze_backbone = True):
+
+    def __init__(self, num_classes, pretrained=True, freeze_backbone=True):
         super(DeepLabV3Transfer, self).__init__()
-        self.base = deeplabv3_resnet50(
-            pretrained = pretrained,
-            num_classes = num_classes
-        )
+        self.base = deeplabv3_resnet50(pretrained=pretrained, num_classes=num_classes)
 
         if freeze_backbone:
             for parameter in self.base.backbone.parameters():
                 parameter.requires_grad = False
 
-    def forward(self, x, **kwargs): # noqa
-        return self.base(x)['out']
+    def forward(self, x, **kwargs):  # noqa
+        return self.base(x)["out"]
 
 
 def dice_loss(y_pred, y):
     y = y.float()
-    try: # Multi-class segmentation
+    try:  # Multi-class segmentation
         c, h, w = y.shape[1:]
-    except: # Binary segmentation
-        h, w = y.shape[1:]; c = 1 # noqa
+    except:  # Binary segmentation
+        h, w = y.shape[1:]
+        c = 1  # noqa
     y_pred = torch.sigmoid(y_pred)
     pred_flat = torch.reshape(y_pred, [-1, c * h * w])
     y_flat = torch.reshape(y, [-1, c * h * w])
-    intersection = 2.0 * torch.sum(pred_flat * y_flat, dim = 1) + 1e-6
-    denominator = torch.sum(pred_flat, dim = 1) + torch.sum(y_flat, dim = 1) + 1e-6
-    return 1. - torch.mean(intersection / denominator)
+    intersection = 2.0 * torch.sum(pred_flat * y_flat, dim=1) + 1e-6
+    denominator = torch.sum(pred_flat, dim=1) + torch.sum(y_flat, dim=1) + 1e-6
+    return 1.0 - torch.mean(intersection / denominator)
 
 
 def dice_metric(y_pred, y):
@@ -75,8 +73,8 @@ def dice_metric(y_pred, y):
 
 class SegmentationBenchmark(pl.LightningModule):
     """Represents an image classification benchmark model."""
-    def __init__(self, dataset, pretrained = False,
-                 save_dir = None, freeze_backbone = False):
+
+    def __init__(self, dataset, pretrained=False, save_dir=None, freeze_backbone=False):
         # Initialize the module.
         super(SegmentationBenchmark, self).__init__()
 
@@ -84,9 +82,7 @@ def __init__(self, dataset, pretrained = False,
         self._source = agml.data.source(dataset)
         self._pretrained = pretrained
         self.net = DeepLabV3Transfer(
-            self._source.num_classes,
-            self._pretrained,
-            freeze_backbone
+            self._source.num_classes, self._pretrained, freeze_backbone
         )
 
         # Construct the loss for training.
@@ -101,9 +97,10 @@ def __init__(self, dataset, pretrained = False,
 
         # Add a metric calculator.
         if save_dir is not None:
-            self.metric_logger = SegmentationMetricLogger({
-                'iou': IoU(self._source.num_classes + 1)},
-                os.path.join(save_dir, f'logs-{self._version}.csv'))
+            self.metric_logger = SegmentationMetricLogger(
+                {"iou": IoU(self._source.num_classes + 1)},
+                os.path.join(save_dir, f"logs-{self._version}.csv"),
+            )
         self._sanity_check_passed = False
 
     def forward(self, x):
@@ -114,30 +111,48 @@ def calculate_loss(self, y_pred, y):
             return self.loss(y_pred, y.long())
         return self.loss(y_pred, y.float())
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x).float().squeeze()
         loss = self.calculate_loss(y_pred, y)
         iou = self.iou(y_pred, y.int())
-        self.log('loss', loss.item(), prog_bar = True, logger = True, on_step = True, on_epoch = True)
-        self.log('iou', iou.item(), prog_bar = True, logger = True, on_step = True, on_epoch = True)
+        self.log(
+            "loss", loss.item(), prog_bar=True, logger=True, on_step=True, on_epoch=True
+        )
+        self.log(
+            "iou", iou.item(), prog_bar=True, logger=True, on_step=True, on_epoch=True
+        )
         return {
-            'loss': loss,
+            "loss": loss,
         }
 
-    def validation_step(self, batch, *args, **kwargs): # noqa
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
         y_pred = self(x).float().squeeze()
         val_loss = self.calculate_loss(y_pred, y)
-        self.log('val_loss', val_loss.item(), prog_bar = True, logger = True, on_step = True, on_epoch = True)
+        self.log(
+            "val_loss",
+            val_loss.item(),
+            prog_bar=True,
+            logger=True,
+            on_step=True,
+            on_epoch=True,
+        )
         val_iou = self.iou(y_pred, y.int())
-        if self._sanity_check_passed and hasattr(self, 'metric_logger'):
+        if self._sanity_check_passed and hasattr(self, "metric_logger"):
             self.metric_logger.update_metrics(y_pred, y.int())
-        self.log('val_iou', val_iou.item(), prog_bar = True, logger = True, on_step = True, on_epoch = True)
+        self.log(
+            "val_iou",
+            val_iou.item(),
+            prog_bar=True,
+            logger=True,
+            on_step=True,
+            on_epoch=True,
+        )
         return {
-            'val_loss': val_loss,
-            'image_sample': x[0].cpu().detach(),
-            'segmentation_sample': y_pred[0].cpu().detach()
+            "val_loss": val_loss,
+            "image_sample": x[0].cpu().detach(),
+            "segmentation_sample": y_pred[0].cpu().detach(),
         }
 
     # def validation_epoch_end(self, outputs):
@@ -158,34 +173,36 @@ def predict(self, inp):
         return torch.sigmoid(self(inp))
 
     def configure_optimizers(self):
-        opt = torch.optim.AdamW(self.net.parameters(), lr = 0.0005)
+        opt = torch.optim.AdamW(self.net.parameters(), lr=0.0005)
         return {
-            'optimizer': opt,
-            'lr_scheduler': torch.optim.lr_scheduler.StepLR(opt, step_size = 5, gamma = 0.75)
+            "optimizer": opt,
+            "lr_scheduler": torch.optim.lr_scheduler.StepLR(
+                opt, step_size=5, gamma=0.75
+            ),
         }
 
     def test_step(self, batch, *args, **kwargs):
         x, y = batch
         y_pred = self(x).float().squeeze()
         loss = self.calculate_loss(y_pred, y)
-        self.log('test_loss', loss.item(), logger = True)
+        self.log("test_loss", loss.item(), logger=True)
         test_iou = self.iou(y_pred, y.int())
-        self.log('test_iou', test_iou.item(), logger = True)
+        self.log("test_iou", test_iou.item(), logger=True)
 
     def get_progress_bar_dict(self):
         tqdm_dict = super(SegmentationBenchmark, self).get_progress_bar_dict()
-        tqdm_dict.pop('v_num', None)
+        tqdm_dict.pop("v_num", None)
         return tqdm_dict
 
     def on_validation_epoch_end(self) -> None:
         if not self._sanity_check_passed:
             self._sanity_check_passed = True
             return
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.compile_epoch()
 
     def on_fit_end(self) -> None:
-        if hasattr(self, 'metric_logger'):
+        if hasattr(self, "metric_logger"):
             self.metric_logger.save()
 
 
@@ -200,118 +217,137 @@ def update_metrics(self, y_pred, y_true) -> None:
 def build_loaders(name):
     pl.seed_everything(2499751)
     loader = agml.data.AgMLDataLoader(name)
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
-    loader.batch(batch_size = 8)
+    loader.split(train=0.8, val=0.1, test=0.1)
+    loader.batch(batch_size=8)
     loader.resize_images((512, 512))
-    loader.normalize_images('imagenet')
+    loader.normalize_images("imagenet")
     loader.mask_to_channel_basis()
     train_data = loader.train_data
-    train_data.transform(transform = A.RandomRotate90())
+    train_data.transform(transform=A.RandomRotate90())
     train_ds = train_data.copy().as_torch_dataset()
-    train_loader = train_ds.export_torch(num_workers = 12, collate_fn = None)
+    train_loader = train_ds.export_torch(num_workers=12, collate_fn=None)
     val_ds = loader.val_data.as_torch_dataset()
     val_ds.shuffle_data = False
-    val_loader = val_ds.export_torch(num_workers = 12, collate_fn = None)
+    val_loader = val_ds.export_torch(num_workers=12, collate_fn=None)
     test_ds = loader.test_data.as_torch_dataset()
-    test_ds.batch(batch_size = 2)
+    test_ds.batch(batch_size=2)
     test_ds.eval()
     return train_loader, val_loader, test_ds
 
 
-def train(dataset, pretrained, epochs, save_dir = None,
-          freeze_backbone = False, overwrite = None):
+def train(
+    dataset, pretrained, epochs, save_dir=None, freeze_backbone=False, overwrite=None
+):
     """Constructs the training loop and trains a model."""
     save_dir = os.path.dirname(checkpoint_dir(save_dir, dataset))
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Construct the model.
     model = SegmentationBenchmark(
-        dataset = dataset, pretrained = pretrained,
-        save_dir = save_dir, freeze_backbone = freeze_backbone)
+        dataset=dataset,
+        pretrained=pretrained,
+        save_dir=save_dir,
+        freeze_backbone=freeze_backbone,
+    )
 
     # Construct the data loaders.
     train_ds, val_ds, test_ds = build_loaders(dataset)
 
     # Create the loggers.
     loggers = [
-        WandbLogger(project = 'segmentation-benchmarking',
-                    name = dataset, save_dir = save_dir)
+        WandbLogger(
+            project="segmentation-benchmarking", name=dataset, save_dir=save_dir
+        )
     ]
 
     # Create the trainer and train the model.
     msg = f"Training dataset {dataset}!"
     print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
     trainer = pl.Trainer(
-        max_epochs = epochs, gpus = gpus(),
-        logger = loggers, log_every_n_steps = 2,
-        callbacks = LearningRateMonitor('epoch'))
-    trainer.fit(
-        model = model,
-        train_dataloaders = train_ds,
-        val_dataloaders = val_ds)
+        max_epochs=epochs,
+        gpus=gpus(),
+        logger=loggers,
+        log_every_n_steps=2,
+        callbacks=LearningRateMonitor("epoch"),
+    )
+    trainer.fit(model=model, train_dataloaders=train_ds, val_dataloaders=val_ds)
 
     # Save the final state.
-    torch.save(model.state_dict(), os.path.join(save_dir, 'final_model.pth'))
+    torch.save(model.state_dict(), os.path.join(save_dir, "final_model.pth"))
 
     # Run on the test set.
-    trainer.test(dataloaders = test_ds)
+    trainer.test(dataloaders=test_ds)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--regenerate-existing', action = 'store_true',
-        default = False, help = "Whether to re-generate existing benchmarks.")
+        "--regenerate-existing",
+        action="store_true",
+        default=False,
+        help="Whether to re-generate existing benchmarks.",
+    )
     ap.add_argument(
-        '--pretrained', action = 'store_true',
-        default = False, help = "Whether to load a pretrained model.")
+        "--pretrained",
+        action="store_true",
+        default=False,
+        help="Whether to load a pretrained model.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 20,
-        help = "How many epochs to train for. Default is 20.")
+        "--epochs",
+        type=int,
+        default=20,
+        help="How many epochs to train for. Default is 20.",
+    )
     ap.add_argument(
-        '--freeze-backbone', action = 'store_true',
-        default = False, help = "Whether to freeze backbone weights.")
+        "--freeze-backbone",
+        action="store_true",
+        default=False,
+        help="Whether to freeze backbone weights.",
+    )
     args = ap.parse_args()
 
     # Train the model.
-    if args.dataset[0] in agml.data.public_data_sources(ml_task = 'semantic_segmentation'):
-        train(args.dataset[0],
-              args.pretrained,
-              epochs = args.epochs,
-              save_dir = args.checkpoint_dir,
-              freeze_backbone = args.freeze_backbone)
+    if args.dataset[0] in agml.data.public_data_sources(
+        ml_task="semantic_segmentation"
+    ):
+        train(
+            args.dataset[0],
+            args.pretrained,
+            epochs=args.epochs,
+            save_dir=args.checkpoint_dir,
+            freeze_backbone=args.freeze_backbone,
+        )
     else:
-        if args.dataset[0] == 'all':
-            datasets = [ds for ds in agml.data.public_data_sources(
-                ml_task = 'semantic_segmentation')]
+        if args.dataset[0] == "all":
+            datasets = [
+                ds
+                for ds in agml.data.public_data_sources(ml_task="semantic_segmentation")
+            ]
         else:
             datasets = args.dataset
         for ds in datasets:
-            train(ds,
-                  args.pretrained,
-                  epochs = args.epochs,
-                  save_dir = args.checkpoint_dir,
-                  freeze_backbone = args.freeze_backbone,
-                  overwrite = args.regenerate_existing)
-
-
-
-
-
-
-
-
-
-
+            train(
+                ds,
+                args.pretrained,
+                epochs=args.epochs,
+                save_dir=args.checkpoint_dir,
+                freeze_backbone=args.freeze_backbone,
+                overwrite=args.regenerate_existing,
+            )
diff --git a/experiments/benchmarking/segmentation_lightning_pretrained.py b/experiments/benchmarking/segmentation_lightning_pretrained.py
index ab54516f..27533d8a 100644
--- a/experiments/benchmarking/segmentation_lightning_pretrained.py
+++ b/experiments/benchmarking/segmentation_lightning_pretrained.py
@@ -12,21 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import os
 from collections import OrderedDict
 
+import albumentations as A
+import pytorch_lightning as pl
 import torch
 import torch.nn as nn
-import pytorch_lightning as pl
 from pytorch_lightning.loggers import WandbLogger
+from tools import MetricLogger, checkpoint_dir, gpus
 from torchmetrics import IoU
 from torchvision.models.segmentation import deeplabv3_resnet50
 
 import agml
-import albumentations as A
-
-from tools import gpus, checkpoint_dir, MetricLogger
 
 
 class DeepLabV3Transfer(nn.Module):
@@ -35,47 +34,48 @@ class DeepLabV3Transfer(nn.Module):
     This is the base benchmarking model for semantic segmentation,
     using the DeepLabV3 model with a ResNet50 backbone.
     """
-    def __init__(self, num_classes, pretrained = False,
-                 unfreeze_backbone = False):
+
+    def __init__(self, num_classes, pretrained=False, unfreeze_backbone=False):
         super(DeepLabV3Transfer, self).__init__()
-        self.base = deeplabv3_resnet50(
-            pretrained = False,
-            num_classes = num_classes)
+        self.base = deeplabv3_resnet50(pretrained=False, num_classes=num_classes)
         if pretrained:
-            self.base.load_state_dict(load_checkpoint(), strict = False)
+            self.base.load_state_dict(load_checkpoint(), strict=False)
 
         if not unfreeze_backbone:
             for parameter in self.base.backbone.parameters():
                 parameter.requires_grad = False
 
-    def forward(self, x, **kwargs): # noqa
+    def forward(self, x, **kwargs):  # noqa
         return self.base(x)
 
 
 def load_checkpoint():
     """Loads a ResNet50 pretrained checkpoint."""
-    ckpt_path = "/data2/amnjoshi/resnet50_pretrained/checkpoints/" \
-                "plant_village_classification-epoch42-val_loss_0.05.ckpt"
-    state = torch.load(ckpt_path, map_location = 'cpu')['state_dict']
+    ckpt_path = (
+        "/data2/amnjoshi/resnet50_pretrained/checkpoints/"
+        "plant_village_classification-epoch42-val_loss_0.05.ckpt"
+    )
+    state = torch.load(ckpt_path, map_location="cpu")["state_dict"]
     new_state = []
     for key in state:
-        if key.startswith('net.base'):
-            new_state.append((key.replace('net.base.', 'backbone.'), state[key]))
+        if key.startswith("net.base"):
+            new_state.append((key.replace("net.base.", "backbone."), state[key]))
     new_state = OrderedDict(new_state)
     return new_state
 
 
 def dice_loss(y_pred, y):
     y = y.float()
-    try: # Multi-class segmentation
+    try:  # Multi-class segmentation
         c, h, w = y.shape[1:]
-    except: # Binary segmentation
-        h, w = y.shape[1:]; c = 1 # noqa
+    except:  # Binary segmentation
+        h, w = y.shape[1:]
+        c = 1  # noqa
     pred_flat = torch.reshape(y_pred, [-1, c * h * w])
     y_flat = torch.reshape(y, [-1, c * h * w])
-    intersection = 2.0 * torch.sum(pred_flat * y_flat, dim = 1) + 1e-6
-    denominator = torch.sum(pred_flat, dim = 1) + torch.sum(y_flat, dim = 1) + 1e-6
-    return 1. - torch.mean(intersection / denominator)
+    intersection = 2.0 * torch.sum(pred_flat * y_flat, dim=1) + 1e-6
+    denominator = torch.sum(pred_flat, dim=1) + torch.sum(y_flat, dim=1) + 1e-6
+    return 1.0 - torch.mean(intersection / denominator)
 
 
 def dice_metric(y_pred, y):
@@ -88,8 +88,10 @@ def dice_metric(y_pred, y):
 
 class SegmentationBenchmark(pl.LightningModule):
     """Represents an image classification benchmark model."""
-    def __init__(self, dataset, pretrained = False,
-                 unfreeze_backbone = False, save_dir = None):
+
+    def __init__(
+        self, dataset, pretrained=False, unfreeze_backbone=False, save_dir=None
+    ):
         # Initialize the module.
         super(SegmentationBenchmark, self).__init__()
 
@@ -99,7 +101,7 @@ def __init__(self, dataset, pretrained = False,
         self.net = DeepLabV3Transfer(
             self._source.num_classes,
             self._pretrained,
-            unfreeze_backbone = unfreeze_backbone
+            unfreeze_backbone=unfreeze_backbone,
         )
 
         # Construct the loss for training.
@@ -112,9 +114,10 @@ def __init__(self, dataset, pretrained = False,
         self.iou = IoU(self._source.num_classes + 1)
 
         # Add a metric calculator.
-        self.metric_logger = SegmentationMetricLogger({
-            'iou': IoU(self._source.num_classes + 1)},
-            os.path.join(save_dir, f'logs-{self._version}.csv'))
+        self.metric_logger = SegmentationMetricLogger(
+            {"iou": IoU(self._source.num_classes + 1)},
+            os.path.join(save_dir, f"logs-{self._version}.csv"),
+        )
         self._sanity_check_passed = False
 
     def forward(self, x):
@@ -125,27 +128,27 @@ def calculate_loss(self, y_pred, y):
             return self.loss(y_pred, y.long())
         return self.loss(y_pred, y.float())
 
-    def training_step(self, batch, *args, **kwargs): # noqa
+    def training_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
-        y_pred = self(x)['out'].float().squeeze()
+        y_pred = self(x)["out"].float().squeeze()
         loss = self.calculate_loss(y_pred, y)
         iou = self.iou(y_pred, y.int())
-        self.log('iou', iou.item(), prog_bar = True)
+        self.log("iou", iou.item(), prog_bar=True)
         return {
-            'loss': loss,
+            "loss": loss,
         }
 
-    def validation_step(self, batch, *args, **kwargs): # noqa
+    def validation_step(self, batch, *args, **kwargs):  # noqa
         x, y = batch
-        y_pred = self(x)['out'].float().squeeze()
+        y_pred = self(x)["out"].float().squeeze()
         val_loss = self.calculate_loss(y_pred, y)
-        self.log('val_loss', val_loss.item(), prog_bar = True)
+        self.log("val_loss", val_loss.item(), prog_bar=True)
         val_iou = self.iou(y_pred, y.int())
         if self._sanity_check_passed:
             self.metric_logger.update_metrics(y_pred, y.int())
-        self.log('val_iou', val_iou.item(), prog_bar = True)
+        self.log("val_iou", val_iou.item(), prog_bar=True)
         return {
-            'val_loss': val_loss,
+            "val_loss": val_loss,
         }
 
     def configure_optimizers(self):
@@ -153,7 +156,7 @@ def configure_optimizers(self):
 
     def get_progress_bar_dict(self):
         tqdm_dict = super(SegmentationBenchmark, self).get_progress_bar_dict()
-        tqdm_dict.pop('v_num', None)
+        tqdm_dict.pop("v_num", None)
         return tqdm_dict
 
     def on_validation_epoch_end(self) -> None:
@@ -177,13 +180,13 @@ def update_metrics(self, y_pred, y_true) -> None:
 def build_loaders(name):
     pl.seed_everything(2499751)
     loader = agml.data.AgMLDataLoader(name)
-    loader.split(train = 0.8, val = 0.1, test = 0.1)
-    loader.batch(batch_size = 8)
-    loader.resize_images('imagenet')
+    loader.split(train=0.8, val=0.1, test=0.1)
+    loader.batch(batch_size=8)
+    loader.resize_images("imagenet")
     # loader.normalize_images('imagenet')
     loader.mask_to_channel_basis()
     train_data = loader.train_data
-    train_data.transform(transform = A.RandomRotate90())
+    train_data.transform(transform=A.RandomRotate90())
     train_ds = train_data.copy().as_torch_dataset()
     val_ds = loader.val_data.as_torch_dataset()
     val_ds.shuffle_data = False
@@ -191,107 +194,132 @@ def build_loaders(name):
     return train_ds, val_ds, test_ds
 
 
-def train(dataset, epochs, save_dir = None, pretrained = False,
-          unfreeze_backbone = False, overwrite = None):
+def train(
+    dataset,
+    epochs,
+    save_dir=None,
+    pretrained=False,
+    unfreeze_backbone=False,
+    overwrite=None,
+):
     """Constructs the training loop and trains a model."""
     save_dir = checkpoint_dir(save_dir, dataset)
-    log_dir = save_dir.replace('checkpoints', 'logs')
+    log_dir = save_dir.replace("checkpoints", "logs")
 
     # Check if the dataset already has benchmarks.
     if os.path.exists(save_dir) and os.path.isdir(save_dir):
         if not overwrite and len(os.listdir(save_dir)) >= 4:
-            print(f"Checkpoints already exist for {dataset} "
-                  f"at {save_dir}, skipping generation.")
+            print(
+                f"Checkpoints already exist for {dataset} "
+                f"at {save_dir}, skipping generation."
+            )
             return
 
     # Set up the checkpoint saving callback.
     callbacks = [
         pl.callbacks.ModelCheckpoint(
-            dirpath = save_dir, mode = 'min',
-            filename = f"{dataset}" + "-epoch{epoch:02d}-val_loss_{val_loss:.2f}",
-            monitor = 'val_iou',
-            save_top_k = 3,
-            auto_insert_metric_name = False
+            dirpath=save_dir,
+            mode="min",
+            filename=f"{dataset}" + "-epoch{epoch:02d}-val_loss_{val_loss:.2f}",
+            monitor="val_iou",
+            save_top_k=3,
+            auto_insert_metric_name=False,
         ),
     ]
 
     # Construct the model.
     model = SegmentationBenchmark(
-        dataset = dataset, save_dir = save_dir,
-        pretrained = pretrained,
-        unfreeze_backbone = unfreeze_backbone)
+        dataset=dataset,
+        save_dir=save_dir,
+        pretrained=pretrained,
+        unfreeze_backbone=unfreeze_backbone,
+    )
 
     # Construct the data loaders.
     train_ds, val_ds, test_ds = build_loaders(dataset)
 
     # Create the loggers.
     loggers = [
-        WandbLogger(save_dir = os.path.dirname(log_dir),
-                    name = f'{dataset}-pretrained',
-                    project = 'segmentation-experiments')
+        WandbLogger(
+            save_dir=os.path.dirname(log_dir),
+            name=f"{dataset}-pretrained",
+            project="segmentation-experiments",
+        )
     ]
 
     # Create the trainer and train the model.
     msg = f"Training dataset {dataset}!"
     print("\n" + "=" * len(msg) + "\n" + msg + "\n" + "=" * len(msg) + "\n")
     trainer = pl.Trainer(
-        max_epochs = epochs, gpus = gpus(),
-        callbacks = callbacks, logger = loggers,
-        log_every_n_steps = 5)
-    trainer.fit(
-        model = model,
-        train_dataloaders = train_ds,
-        val_dataloaders = val_ds)
+        max_epochs=epochs,
+        gpus=gpus(),
+        callbacks=callbacks,
+        logger=loggers,
+        log_every_n_steps=5,
+    )
+    trainer.fit(model=model, train_dataloaders=train_ds, val_dataloaders=val_ds)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Parse input arguments.
     ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", type=str, nargs="+", help="The name of the dataset.")
     ap.add_argument(
-        '--dataset', type = str, nargs = '+', help = "The name of the dataset.")
-    ap.add_argument(
-        '--regenerate-existing', action = 'store_true',
-        default = False, help = "Whether to re-generate existing benchmarks.")
+        "--regenerate-existing",
+        action="store_true",
+        default=False,
+        help="Whether to re-generate existing benchmarks.",
+    )
     ap.add_argument(
-        '--pretrained', action = 'store_true',
-        default = False, help = "Whether to load a pretrained model.")
+        "--pretrained",
+        action="store_true",
+        default=False,
+        help="Whether to load a pretrained model.",
+    )
     ap.add_argument(
-        '--checkpoint_dir', type = str, default = None,
-        help = "The checkpoint directory to save to.")
+        "--checkpoint_dir",
+        type=str,
+        default=None,
+        help="The checkpoint directory to save to.",
+    )
     ap.add_argument(
-        '--epochs', type = int, default = 20,
-        help = "How many epochs to train for. Default is 20.")
+        "--epochs",
+        type=int,
+        default=20,
+        help="How many epochs to train for. Default is 20.",
+    )
     ap.add_argument(
-        '--unfreeze-backbone', action = 'store_true',
-        default = False, help = "Whether to not freeze backbone weights.")
+        "--unfreeze-backbone",
+        action="store_true",
+        default=False,
+        help="Whether to not freeze backbone weights.",
+    )
     args = ap.parse_args()
 
     # Train the model.
-    if args.dataset[0] in agml.data.public_data_sources(ml_task = 'semantic_segmentation'):
-        train(dataset = args.dataset[0],
-              epochs = args.epochs,
-              save_dir = args.checkpoint_dir,
-              unfreeze_backbone = args.unfreeze_backbone)
+    if args.dataset[0] in agml.data.public_data_sources(
+        ml_task="semantic_segmentation"
+    ):
+        train(
+            dataset=args.dataset[0],
+            epochs=args.epochs,
+            save_dir=args.checkpoint_dir,
+            unfreeze_backbone=args.unfreeze_backbone,
+        )
     else:
-        if args.dataset[0] == 'all':
-            datasets = [ds for ds in agml.data.public_data_sources(
-                ml_task = 'semantic_segmentation')]
+        if args.dataset[0] == "all":
+            datasets = [
+                ds
+                for ds in agml.data.public_data_sources(ml_task="semantic_segmentation")
+            ]
         else:
             datasets = args.dataset
         for ds in datasets:
-            train(dataset = ds,
-                  epochs = args.epochs,
-                  pretrained = args.pretrained,
-                  save_dir = args.checkpoint_dir,
-                  unfreeze_backbone = args.unfreeze_backbone,
-                  overwrite = args.regenerate_existing)
-
-
-
-
-
-
-
-
-
-
+            train(
+                dataset=ds,
+                epochs=args.epochs,
+                pretrained=args.pretrained,
+                save_dir=args.checkpoint_dir,
+                unfreeze_backbone=args.unfreeze_backbone,
+                overwrite=args.regenerate_existing,
+            )
diff --git a/experiments/benchmarking/tools.py b/experiments/benchmarking/tools.py
index b20cf632..7f886da9 100644
--- a/experiments/benchmarking/tools.py
+++ b/experiments/benchmarking/tools.py
@@ -15,15 +15,14 @@
 import os
 import sys
 from functools import wraps
-from typing import Dict, Callable
+from typing import Callable, Dict
 
 import pandas as pd
-
 import torch
 from torchmetrics import Metric
 
 
-def gpus(given = None):
+def gpus(given=None):
     """Gets the number of GPUs to use based on the experiment."""
     if not torch.cuda.is_available():
         return 0
@@ -32,31 +31,32 @@ def gpus(given = None):
     return torch.cuda.device_count()
 
 
-def checkpoint_dir(given = None, dataset = None):
+def checkpoint_dir(given=None, dataset=None):
     """Returns the directory to save logs/checkpoints to."""
     if given is not None:
-        if given.endswith('dataset'):
+        if given.endswith("dataset"):
             # if a path is passed like /root/dataset, this updates to the name
             given = os.path.dirname(given)
             given = os.path.join(given, dataset)
         if not os.path.exists(given):
-            os.makedirs(given, exist_ok = True)
+            os.makedirs(given, exist_ok=True)
         return given
-    if 'get_ipython()' in globals() and os.path.exists('/content'):
+    if "get_ipython()" in globals() and os.path.exists("/content"):
         # In Google Colab.
-        return '/content/logs'
+        return "/content/logs"
     else:
-        if os.path.exists('/data2'):
+        if os.path.exists("/data2"):
             save_dir = os.path.join(f"/data2/amnjoshi/checkpoints")
         else:
-            save_dir = os.path.join(os.path.dirname(__file__), 'logs')
+            save_dir = os.path.join(os.path.dirname(__file__), "logs")
         save_dir = os.path.join(save_dir, dataset)
-        os.makedirs(save_dir, exist_ok = True)
+        os.makedirs(save_dir, exist_ok=True)
         return save_dir
 
 
 class MetricLogger(object):
     """Logs metrics for training after every epoch."""
+
     def __init__(self, metrics, file):
         if not isinstance(metrics, dict):
             raise TypeError("Expected a dictionary of metrics.")
@@ -64,7 +64,8 @@ def __init__(self, metrics, file):
 
         if not os.path.exists(os.path.dirname(file)):
             raise NotADirectoryError(
-                f"The directory of the file {file} does not exist.")
+                f"The directory of the file {file} does not exist."
+            )
         path_name = os.path.splitext(file)[0]
         file = path_name + ".csv"
         self.out_file = file
@@ -93,7 +94,7 @@ def save(self):
 
         # Compile metrics into a CSV format.
         names = list(self.metrics.keys())
-        df = pd.DataFrame(self.log_outputs, columns = names)
+        df = pd.DataFrame(self.log_outputs, columns=names)
         df.to_csv(self.out_file)
 
 
@@ -138,10 +139,9 @@ def auto_transfer_args(self, *args, **kwargs):
         if not isinstance(self, LightningModule):
             return fn(self, *args, **kwargs)
 
-        args, kwargs = self.transfer_batch_to_device((args, kwargs), device=self.device, dataloader_idx=None)
+        args, kwargs = self.transfer_batch_to_device(
+            (args, kwargs), device=self.device, dataloader_idx=None
+        )
         return fn(self, *args, **kwargs)
 
     return auto_transfer_args
-
-
-
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..19e707f4
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,72 @@
+# simplest build system
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "agml"
+description = "A comprehensive library for agricultural deep learning"
+authors = [{name = "UC Davis Plant AI and Biophysics Lab", email = "jmearles@ucdavis.edu"}]
+maintainers = [{ name="Amogh Joshi", email="amnjoshi@ucdavis.edu"}]
+
+license = {text = "Apache 2.0"}
+readme = "README.md"
+packages = [{include = "agml", from = "agml", exclude ='agml/_internal'}]
+version = "0.7.0"
+requires-python = ">=3.8,<3.12"
+keywords = []
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Documentation",
+    "Topic :: Software Development",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+
+# managed by uv
+dependencies = [
+    "matplotlib>=3.7.5",
+    "numpy>=1.24.4",
+    "opencv-python>=4.10.0.84",
+    "opencv-python-headless>=4.10.0.84",
+    "requests>=2.0.0",
+    "scikit-learn>=1.3.2",
+    "tqdm>=4.67.0",
+    "pyyaml>=6.0.2",
+    "albumentations>=1.4.18",
+    "dict2xml>=1.7.6",
+]
+[project.urls]
+
+
+[project.scripts]
+
+
+
+[tool.uv]
+dev-dependencies = [
+    "boto3>=1.35.66",
+    "scikit-image>=0.21.0",
+    "shapely>=2.0.6",
+    "botocore>=1.35.66",
+    "pandas>=2.0.3",
+    "pytest>=8.3.3",
+    "pytest-order>=1.3.0",
+    "pytest-cov>=5.0.0",
+    "ruff>=0.7.4",
+    "mypy>=1.13.0",
+    "coverage>=7.6.1",
+    "interrogate>=1.7.0",
+]
diff --git a/scripts/convert_lightning_pytorch_ckpt.py b/scripts/convert_lightning_pytorch_ckpt.py
index 5b8ead96..4d9fd0c6 100644
--- a/scripts/convert_lightning_pytorch_ckpt.py
+++ b/scripts/convert_lightning_pytorch_ckpt.py
@@ -14,11 +14,11 @@
 
 """Converts PyTorch Lightning checkpoints to `nn.Module` state dicts."""
 
+import argparse
 import os
 import shutil
-import argparse
-from fnmatch import fnmatch
 from collections import OrderedDict
+from fnmatch import fnmatch
 
 import torch
 
@@ -33,13 +33,13 @@ def convert_state_dict(fpath):
     if isinstance(contents, OrderedDict):
         keys: list[str] = list(contents.keys())
         if len(keys) == 0:
-            print('No state dict found.')
+            print("No state dict found.")
             return
-        if keys[0].startswith('net'):
+        if keys[0].startswith("net"):
             out_dict = OrderedDict()
             for key in contents.keys():
                 value = contents[key]
-                out_dict[key.replace('net.', '')] = value
+                out_dict[key.replace("net.", "")] = value
         else:
             return
 
@@ -47,7 +47,7 @@ def convert_state_dict(fpath):
     # and re-save the file using the same name, just with only
     # the state dict and no PyTorch Lightning values.
     else:
-        state_dict: OrderedDict = contents.get('state_dict', None)
+        state_dict: OrderedDict = contents.get("state_dict", None)
         if state_dict is None:
             print(f"No state dict found in file {fpath}.")
             return
@@ -56,35 +56,32 @@ def convert_state_dict(fpath):
         out_dict = OrderedDict()
         for key in state_dict.keys():
             value = state_dict[key]
-            out_dict[key.replace('net.', '')] = value
+            out_dict[key.replace("net.", "")] = value
 
     # Save the state dict.
-    temp_path = os.path.join(os.path.dirname(fpath), 'temp_state_dict.ckpt')
-    shutil.copy(fpath, temp_path) # save a copy in case an issue occurs
+    temp_path = os.path.join(os.path.dirname(fpath), "temp_state_dict.ckpt")
+    shutil.copy(fpath, temp_path)  # save a copy in case an issue occurs
     os.remove(fpath)
-    torch.save(out_dict, fpath.replace('.ckpt', '.pth'))
+    torch.save(out_dict, fpath.replace(".ckpt", ".pth"))
     os.remove(temp_path)
     print("Conversion Successful.")
 
 
 # Parse input arguments (get the directory to search).
 ap = argparse.ArgumentParser()
-ap.add_argument('--search_dir', type = str, required = True,
-                help = 'The directory containing all of the checkpoints that you want'
-                       'to convert. This will search for all nested folders and files '
-                       'in the provided directory.')
+ap.add_argument(
+    "--search_dir",
+    type=str,
+    required=True,
+    help="The directory containing all of the checkpoints that you want"
+    "to convert. This will search for all nested folders and files "
+    "in the provided directory.",
+)
 search_dir = ap.parse_args().search_dir
 
 # Search through and convert all of the files.
 for path, subdirs, files in os.walk(os.path.abspath(os.path.normpath(search_dir))):
     for name in files:
-        if fnmatch(name, '*.ckpt') or fnmatch(name, '*.pth'):
-            print(f"Converting checkpoint at '{os.path.join(path, name)}'... ", end = '')
+        if fnmatch(name, "*.ckpt") or fnmatch(name, "*.pth"):
+            print(f"Converting checkpoint at '{os.path.join(path, name)}'... ", end="")
             convert_state_dict(os.path.join(path, name))
-
-
-
-
-
-
-
diff --git a/scripts/format_json_source.py b/scripts/format_json_source.py
index 197f33bd..4ac85bf3 100644
--- a/scripts/format_json_source.py
+++ b/scripts/format_json_source.py
@@ -16,21 +16,29 @@
 Convenience script to reformat the public data source
 JSON file in a nicer-looking format (for readability).
 """
-import os
+
 import json
+import os
 
-SOURCE_PATH = os.path.join(os.path.dirname(
-    os.path.dirname(__file__)), 'agml', '_assets', 'public_datasources.json')
-CITATION_PATH = os.path.join(os.path.dirname(
-    os.path.dirname(__file__)), 'agml', '_assets', 'source_citations.json')
+SOURCE_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(__file__)),
+    "agml",
+    "_assets",
+    "public_datasources.json",
+)
+CITATION_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(__file__)),
+    "agml",
+    "_assets",
+    "source_citations.json",
+)
 
-with open(SOURCE_PATH, 'r') as f:
+with open(SOURCE_PATH, "r") as f:
     contents = json.load(f)
-with open(SOURCE_PATH, 'w') as f:
-    json.dump(contents, f, indent = 4)
+with open(SOURCE_PATH, "w") as f:
+    json.dump(contents, f, indent=4)
 
-with open(CITATION_PATH, 'r') as f:
+with open(CITATION_PATH, "r") as f:
     contents = json.load(f)
-with open(CITATION_PATH, 'w') as f:
-    json.dump(contents, f, indent = 4)
-
+with open(CITATION_PATH, "w") as f:
+    json.dump(contents, f, indent=4)
diff --git a/scripts/generate_dataset_markdown.py b/scripts/generate_dataset_markdown.py
index b208fe47..4e5ad813 100644
--- a/scripts/generate_dataset_markdown.py
+++ b/scripts/generate_dataset_markdown.py
@@ -20,9 +20,9 @@
 import random
 
 import cv2
+import matplotlib.pyplot as plt
 import numpy as np
 from tqdm import tqdm
-import matplotlib.pyplot as plt
 
 import agml
 from agml.utils.data import load_public_sources
@@ -53,26 +53,29 @@ def __missing__(self, key):
 {examples}"""
 
 # Unused keys.
-UNUSED_KEYS = ['external_image_sources']
+UNUSED_KEYS = ["external_image_sources"]
 
 # Substitutions for metadata category names and values.
-substitutions = DefaultDict({
-    'Ml Task': 'Machine Learning Task',
-    'Ag Task': 'Agricultural Task',
-    'Real Synthetic': 'Real or Synthetic',
-    'N Images': 'Number of Images',
-    'Docs Url': 'Documentation',
-    'Usa': 'United States',
-    'rgb': 'RGB',
-    'lidar': 'LiDAR',
-    'jpg': 'JPG',
-    'png': 'PNG',
-    'jpeg': 'JPEG'
-})
+substitutions = DefaultDict(
+    {
+        "Ml Task": "Machine Learning Task",
+        "Ag Task": "Agricultural Task",
+        "Real Synthetic": "Real or Synthetic",
+        "N Images": "Number of Images",
+        "Docs Url": "Documentation",
+        "Usa": "United States",
+        "rgb": "RGB",
+        "lidar": "LiDAR",
+        "jpg": "JPG",
+        "png": "PNG",
+        "jpeg": "JPEG",
+    }
+)
 
 
 class TableFormat(object):
     """Constructs a proper table format for the given key."""
+
     @staticmethod
     def handle(key, value):
         method = getattr(TableFormat, key, None)
@@ -80,25 +83,29 @@ def handle(key, value):
             return method(value)
         if isinstance(value, list):
             value = ", ".join(value)
-        if value == '': value = "None"
-        return f'| **{substitutions[to_title(key)]}** | {substitutions[value]} |\n'
-    
+        if value == "":
+            value = "None"
+        return f"| **{substitutions[to_title(key)]}** | {substitutions[value]} |\n"
+
     @staticmethod
-    def stats(value): # noqa
-        return f"| **Stats/Mean** | [{', '.join(str(round(i, 3)) for i in value['mean'])}] |\n" \
-               f"| **Stats/Standard Deviation** | [{', '.join(str(round(i, 3)) for i in value['std'])}] |\n"
+    def stats(value):  # noqa
+        return (
+            f"| **Stats/Mean** | [{', '.join(str(round(i, 3)) for i in value['mean'])}] |\n"
+            f"| **Stats/Standard Deviation** | [{', '.join(str(round(i, 3)) for i in value['std'])}] |\n"
+        )
 
     @staticmethod
     def classes(value):
         print(value)
-        return "| **Classes** | {} |\n".format(', '.join(value.values()))
+        return "| **Classes** | {} |\n".format(", ".join(value.values()))
 
     @staticmethod
     def location(value):
-        if value['continent'] == 'worldwide':
+        if value["continent"] == "worldwide":
             return "| **Location** | Worldwide |\n"
         return "| **Location** | {}, {} |\n".format(
-            substitutions[to_title(value['country'])], to_title(value['continent']))
+            substitutions[to_title(value["country"])], to_title(value["continent"])
+        )
 
 
 def get_source_info(source):
@@ -107,12 +114,12 @@ def get_source_info(source):
 
 
 def to_title(name):
-    return ' '.join(i.title() for i in name.split('_'))
+    return " ".join(i.title() for i in name.split("_"))
 
 
 def build_table(json):
     """Builds a markdown table from the given json."""
-    table = '| Metadata | Value |\n| --- | --- |\n'
+    table = "| Metadata | Value |\n| --- | --- |\n"
     for key, value in json.items():
         if key in UNUSED_KEYS:
             continue
@@ -136,24 +143,29 @@ def show_sample(loader, image_only=False, num_images=1, **kwargs):
     -------
     The matplotlib figure showing the requested number of images.
     """
-    if kwargs.get('sample', None) is not None:
-        sample = kwargs['sample']
+    if kwargs.get("sample", None) is not None:
+        sample = kwargs["sample"]
     else:
         sample = loader[0]
     if image_only:
         return agml.viz.show_images(sample[0])
 
-    if loader.task == 'object_detection':
+    if loader.task == "object_detection":
         # Collect 4 images (or as many as available if fewer)
         samples = [loader[i] for i in range(min(len(loader), 4))]
-        return [agml.viz.show_image_and_boxes(
-            sample, info=loader.info, no_show=kwargs.get('no_show', False)) for sample in samples]
+        return [
+            agml.viz.show_image_and_boxes(
+                sample, info=loader.info, no_show=kwargs.get("no_show", False)
+            )
+            for sample in samples
+        ]
 
-    elif loader.task == 'semantic_segmentation':
+    elif loader.task == "semantic_segmentation":
         return agml.viz.show_image_and_overlaid_mask(
-            sample, no_show = kwargs.get('no_show', False))
+            sample, no_show=kwargs.get("no_show", False)
+        )
 
-    elif loader.task == 'image_classification':
+    elif loader.task == "image_classification":
         # Fetch all available classes and initialize an empty list for samples.
         classes = loader.classes
         num_classes = len(classes)
@@ -169,9 +181,9 @@ def show_sample(loader, image_only=False, num_images=1, **kwargs):
 
             # Map label to its class index (if necessary)
             if isinstance(label, (list, np.ndarray)):  # Handle one-hot encoding case
-                label = np.argmax(label) # Adjust indexing to start from 1
+                label = np.argmax(label)  # Adjust indexing to start from 1
             if isinstance(label, dict):
-                label = label.get('label', None)
+                label = label.get("label", None)
             if label in class_to_sample and class_to_sample[label] is None:
                 class_to_sample[label] = sample
 
@@ -180,7 +192,11 @@ def show_sample(loader, image_only=False, num_images=1, **kwargs):
                 break
 
         # Collect samples ensuring uniqueness per class until we hit num_classes.
-        samples = [class_to_sample[cls] for cls in range(num_classes) if class_to_sample[cls] is not None]
+        samples = [
+            class_to_sample[cls]
+            for cls in range(num_classes)
+            if class_to_sample[cls] is not None
+        ]
 
         # If more images are required, duplicate randomly from the collected samples.
         if num_images > num_classes:
@@ -191,14 +207,15 @@ def show_sample(loader, image_only=False, num_images=1, **kwargs):
         if num_images <= num_classes:
             samples = samples[:num_images]
         return agml.viz.show_images_and_labels(
-            samples, info=loader.info, no_show=kwargs.get('no_show', False))
+            samples, info=loader.info, no_show=kwargs.get("no_show", False)
+        )
 
 
 def generate_example_images(name):
     """Generates multiple example images for the given dataset."""
     agml.backend.set_seed(189)
     loader = agml.data.AgMLDataLoader(name)  # Ensure the batch size is correct
-    return show_sample(loader, num_images=max(4,len(loader.classes)), no_show=True)
+    return show_sample(loader, num_images=max(4, len(loader.classes)), no_show=True)
 
 
 def build_examples(name):
@@ -213,7 +230,9 @@ def build_examples(name):
             elif isinstance(sample, np.ndarray):
                 image = sample  # If it's directly an image
             else:
-                print(f"Error: Sample {idx} is not a valid image format. Type: {type(sample)}")
+                print(
+                    f"Error: Sample {idx} is not a valid image format. Type: {type(sample)}"
+                )
                 continue
             images.append(image)
 
@@ -226,72 +245,78 @@ def build_examples(name):
         for i, ax in enumerate(axes.flat):
             if i < len(images):
                 ax.imshow(images[i])
-                ax.axis('off')
+                ax.axis("off")
             else:
-                ax.axis('off')
+                ax.axis("off")
         # Save the combined image
-        save_path_local = os.path.join(LOCAL_AGML_REPO, 'docs/sample_images', f'{name}_examples.png')
-        plt.savefig(save_path_local, bbox_inches='tight')
+        save_path_local = os.path.join(
+            LOCAL_AGML_REPO, "docs/sample_images", f"{name}_examples.png"
+        )
+        plt.savefig(save_path_local, bbox_inches="tight")
         plt.close()
         print(f"Combined image saved to {save_path_local}")
-        save_path_remote = os.path.join(AGML_REPO, 'docs/sample_images', f'{name}_examples.png')
-        return f'![Example Images for {name}]({save_path_remote})'
+        save_path_remote = os.path.join(
+            AGML_REPO, "docs/sample_images", f"{name}_examples.png"
+        )
+        return f"![Example Images for {name}]({save_path_remote})"
 
     else:
         save_path_local = os.path.join(
-            LOCAL_AGML_REPO, 'docs/sample_images', f'{name}_examples.png')
+            LOCAL_AGML_REPO, "docs/sample_images", f"{name}_examples.png"
+        )
         save_path_remote = os.path.join(
-            AGML_REPO, 'docs/sample_images', f'{name}_examples.png')
+            AGML_REPO, "docs/sample_images", f"{name}_examples.png"
+        )
         cv2.imwrite(save_path_local, samples)
-        return f'![Example Images for {name}]({save_path_remote})'
+        return f"![Example Images for {name}]({save_path_remote})"
 
 
 def generate_markdown(name):
-    with open(os.path.join(LOCAL_AGML_REPO, 'docs/datasets', f'{name}.md'), 'w') as f:
-        f.write(MARKDOWN_TEMPLATE.format(
-            name = name,
-            table = build_table(get_source_info(name)),
-            examples = build_examples(name)))
+    with open(os.path.join(LOCAL_AGML_REPO, "docs/datasets", f"{name}.md"), "w") as f:
+        f.write(
+            MARKDOWN_TEMPLATE.format(
+                name=name,
+                table=build_table(get_source_info(name)),
+                examples=build_examples(name),
+            )
+        )
 
 
 def update_readme(datasets):
     # Find the part of the README where datasets are listed out.
-    with open(os.path.join(LOCAL_AGML_REPO, 'README.md'), 'r') as f:
+    with open(os.path.join(LOCAL_AGML_REPO, "README.md"), "r") as f:
         original_readme = [i[:-1] for i in f.readlines()]
-    with open(os.path.join(LOCAL_AGML_REPO, 'README.md'), 'r') as f:
+    with open(os.path.join(LOCAL_AGML_REPO, "README.md"), "r") as f:
         original_readme_full = f.read()
-    end_line = original_readme.index('## Usage Information') - 1
+    end_line = original_readme.index("## Usage Information") - 1
 
     # Update the README.
     for ds in tqdm(datasets):
         if ds.name not in original_readme_full:
-            content = '[{name}]({url}) | {task} | {num_images} |'.format(
-                name = ds.name,
-                url = f'https://github.com/Project-AgML/AgML/blob/main/docs/datasets/{ds.name}.md',
-                task = to_title(ds.tasks.ml),
-                num_images = ds.num_images
+            content = "[{name}]({url}) | {task} | {num_images} |".format(
+                name=ds.name,
+                url=f"https://github.com/Project-AgML/AgML/blob/main/docs/datasets/{ds.name}.md",
+                task=to_title(ds.tasks.ml),
+                num_images=ds.num_images,
             )
             original_readme.insert(end_line, content)
             end_line += 1
 
     # Rewrite the README.
-    with open(os.path.join(LOCAL_AGML_REPO, 'README.md'), 'w') as f:
-        f.write('\n'.join(original_readme))
+    with open(os.path.join(LOCAL_AGML_REPO, "README.md"), "w") as f:
+        f.write("\n".join(original_readme))
 
 
-if __name__ == '__main__':
-    os.makedirs(os.path.join(LOCAL_AGML_REPO, 'docs/datasets'), exist_ok = True)
-    os.makedirs(os.path.join(LOCAL_AGML_REPO, 'docs/sample_images'), exist_ok = True)
+if __name__ == "__main__":
+    os.makedirs(os.path.join(LOCAL_AGML_REPO, "docs/datasets"), exist_ok=True)
+    os.makedirs(os.path.join(LOCAL_AGML_REPO, "docs/sample_images"), exist_ok=True)
     datasets = agml.data.public_data_sources()
     for ds in tqdm(datasets):
-        if not os.path.exists(os.path.join(LOCAL_AGML_REPO, 'docs/datasets', f'{ds.name}.md')):
+        if not os.path.exists(
+            os.path.join(LOCAL_AGML_REPO, "docs/datasets", f"{ds.name}.md")
+        ):
             generate_markdown(ds.name)
             pass
 
     # Update the README with any new datasets.
     update_readme(datasets)
-
-
-
-
-
diff --git a/scripts/generate_normalization_info.py b/scripts/generate_normalization_info.py
index 74531938..72918e09 100644
--- a/scripts/generate_normalization_info.py
+++ b/scripts/generate_normalization_info.py
@@ -16,70 +16,76 @@
 Generates the normalization info for new or changed datasets.
 """
 
-import os
+import argparse
 import json
+import os
 import shutil
-import argparse
 
-import agml
 import numpy as np
 from tqdm import tqdm
 
+import agml
+
 # Parse input arguments (get the datasets to re-generate).
 ap = argparse.ArgumentParser()
-ap.add_argument('--datasets', nargs = '+', required = True,
-                help = 'The datasets you want to generate (or re-generate) shape information '
-                       'for. These should be in the `public_datasources.json` file, and if it is'
-                       'a new dataset, the folder should be in `~/.agml/datasets`. To re-generate'
-                       'shape information for all datasets, use the "all" command. ')
+ap.add_argument(
+    "--datasets",
+    nargs="+",
+    required=True,
+    help="The datasets you want to generate (or re-generate) shape information "
+    "for. These should be in the `public_datasources.json` file, and if it is"
+    "a new dataset, the folder should be in `~/.agml/datasets`. To re-generate"
+    'shape information for all datasets, use the "all" command. ',
+)
 datasets = ap.parse_args().datasets
 
 # Load in the original contents of the data sources JSON.
 source_info_file = os.path.join(
-        os.path.dirname(os.path.dirname(__file__)),
-        'agml', '_assets', 'public_datasources.json')
+    os.path.dirname(os.path.dirname(__file__)),
+    "agml",
+    "_assets",
+    "public_datasources.json",
+)
 if os.path.exists(source_info_file):
-    with open(source_info_file, 'r') as f:
+    with open(source_info_file, "r") as f:
         source_info = json.load(f)
 else:
-    raise ValueError(f"The public data source file is missing "
-                     f"(found nothing at {source_info_file}.")
+    raise ValueError(
+        f"The public data source file is missing "
+        f"(found nothing at {source_info_file}."
+    )
 
 # Determine which datasets to download.
-if datasets[0] == 'all':
+if datasets[0] == "all":
     datasets = agml.data.public_data_sources()
 else:
     datasets = [agml.data.source(i) for i in datasets]
 
 # Parse through and calculate the mean/std.
-for ds in tqdm(datasets, desc = 'Processing Datasets'):
+for ds in tqdm(datasets, desc="Processing Datasets"):
     leave = True
-    if not os.path.exists(os.path.join(
-            os.path.expanduser('~'), '.agml', 'datasets', ds.name)):
+    if not os.path.exists(
+        os.path.join(os.path.expanduser("~"), ".agml", "datasets", ds.name)
+    ):
         leave = False
     loader = agml.data.AgMLDataLoader(ds if isinstance(ds, str) else ds.name)
 
     # Get the mean/std of individual images.
-    num_images, mean, std = 0, 0., 0.
-    for contents in tqdm(loader, desc = 'Loader Iteration', leave = False):
+    num_images, mean, std = 0, 0.0, 0.0
+    for contents in tqdm(loader, desc="Loader Iteration", leave=False):
         num_images += 1
-        image, _ = contents # noqa
+        image, _ = contents  # noqa
         if isinstance(image, dict):
-            image = image['image']
+            image = image["image"]
         image = (image / 255).astype(np.float32)
         image = np.reshape(np.transpose(image, (2, 0, 1)), (3, -1))
         mean += image.mean(-1)
         std += image.std(-1)
-    mean = tuple((mean / num_images).tolist()) # noqa
-    std = tuple((std / num_images).tolist()) # noqa
-    source_info[loader.name]['stats'] = {
-        'mean': tuple(mean),
-        'std': tuple(std)
-    }
+    mean = tuple((mean / num_images).tolist())  # noqa
+    std = tuple((std / num_images).tolist())  # noqa
+    source_info[loader.name]["stats"] = {"mean": tuple(mean), "std": tuple(std)}
     if not leave:
         shutil.rmtree(loader.dataset_root)
 
-with open(source_info_file, 'w') as f:
-    json.dump(source_info, f, indent = 4)
-
-
+with open(source_info_file, "w") as f:
+    json.dump(source_info, f, indent=4)
diff --git a/scripts/generate_shape_info.py b/scripts/generate_shape_info.py
index f51df7b9..e094dc4b 100644
--- a/scripts/generate_shape_info.py
+++ b/scripts/generate_shape_info.py
@@ -16,59 +16,62 @@
 Generates the shape information file for new datasets or changed datasets.
 """
 
+import argparse
 import os
 import pickle
 import shutil
-import argparse
 
-import agml
 import numpy as np
 from tqdm import tqdm
 
+import agml
+
 # Parse input arguments (get the datasets to re-generate).
 ap = argparse.ArgumentParser()
-ap.add_argument('--datasets', nargs = '+', required = True,
-                help = 'The datasets you want to generate (or re-generate) shape information '
-                       'for. These should be in the `public_datasources.json` file, and if it is'
-                       'a new dataset, the folder should be in `~/.agml/datasets`. To re-generate'
-                       'shape information for all datasets, use the "all" command. ')
+ap.add_argument(
+    "--datasets",
+    nargs="+",
+    required=True,
+    help="The datasets you want to generate (or re-generate) shape information "
+    "for. These should be in the `public_datasources.json` file, and if it is"
+    "a new dataset, the folder should be in `~/.agml/datasets`. To re-generate"
+    'shape information for all datasets, use the "all" command. ',
+)
 datasets = ap.parse_args().datasets
 
 # Load in the original contents of the shape info file.
 shape_info_file = os.path.join(
-        os.path.dirname(os.path.dirname(__file__)),
-        'agml', '_assets', 'shape_info.pickle')
+    os.path.dirname(os.path.dirname(__file__)), "agml", "_assets", "shape_info.pickle"
+)
 if os.path.exists(shape_info_file):
-    with open(shape_info_file, 'rb') as f:
+    with open(shape_info_file, "rb") as f:
         shape_contents = pickle.load(f)
 else:
     shape_contents = {}
 
 # Determine which datasets to download.
-if datasets[0] == 'all':
+if datasets[0] == "all":
     datasets = agml.data.public_data_sources()
 
 # Parse through and update the shape contents.
-for ds in tqdm(datasets, desc = 'Processing Datasets'):
-    if hasattr(ds, 'name'):
+for ds in tqdm(datasets, desc="Processing Datasets"):
+    if hasattr(ds, "name"):
         ds = ds.name
     current_shapes, leave = [], True
-    if not os.path.exists(os.path.join(
-            os.path.expanduser('~'), '.agml', 'datasets', ds)):
+    if not os.path.exists(
+        os.path.join(os.path.expanduser("~"), ".agml", "datasets", ds)
+    ):
         leave = False
     loader = agml.data.AgMLDataLoader(ds)
-    for contents in tqdm(loader, desc = 'Loader Iteration', leave = False):
+    for contents in tqdm(loader, desc="Loader Iteration", leave=False):
         image, _ = contents
         if isinstance(image, dict):
-            image = image['image']
+            image = image["image"]
         current_shapes.append(image.shape)
-    shape_contents[loader.name] = np.unique(
-        current_shapes, return_counts = True, axis = 0)
+    shape_contents[loader.name] = np.unique(current_shapes, return_counts=True, axis=0)
     if not leave:
         shutil.rmtree(loader.dataset_root)
 
 # Save the contents once again.
-with open(shape_info_file, 'wb') as f:
+with open(shape_info_file, "wb") as f:
     pickle.dump(shape_contents, f)
-
-
diff --git a/scripts/run_full_dataset_update.py b/scripts/run_full_dataset_update.py
index 8a6b14f0..1bf79018 100644
--- a/scripts/run_full_dataset_update.py
+++ b/scripts/run_full_dataset_update.py
@@ -1,27 +1,30 @@
 #!/usr/bin/env python3
 # -*- coding = utf-8 -*-
-import os
 import json
+import os
 
 import agml
 
-
 # Check whether any dataset has been added that needs information updated (we do this
 # by checking for any datasets in the `public_datasources.json` file that don't have
 # corresponding information for the dataset statistics or other properties like shape).
-with open(os.path.join(os.path.dirname(os.path.dirname(__file__)),
-                       'agml', '_assets', 'public_datasources.json')) as f:
+with open(
+    os.path.join(
+        os.path.dirname(os.path.dirname(__file__)),
+        "agml",
+        "_assets",
+        "public_datasources.json",
+    )
+) as f:
     source_info = json.load(f)
 
 # Get the datasets that need to be updated.
-datasets = [i for i in source_info if 'stats' not in source_info[i]]
+datasets = [i for i in source_info if "stats" not in source_info[i]]
 print("DATASETS TO UPDATE:", datasets)
 
 # For each of the datasets which need to be updated, run the corresponding update scripts.
 for dataset in datasets:
-    agml.data.download_public_dataset(dataset) # only download dataset once
-    os.system(f'python3 scripts/generate_normalization_info.py --datasets {dataset}')
-    os.system(f'python3 scripts/generate_shape_info.py --datasets {dataset}')
-    os.system(f'python3 scripts/generate_dataset_markdown.py')
-
-
+    agml.data.download_public_dataset(dataset)  # only download dataset once
+    os.system(f"python3 scripts/generate_normalization_info.py --datasets {dataset}")
+    os.system(f"python3 scripts/generate_shape_info.py --datasets {dataset}")
+    os.system(f"python3 scripts/generate_dataset_markdown.py")
diff --git a/setup.py b/setup.py
deleted file mode 100644
index eed31bc8..00000000
--- a/setup.py
+++ /dev/null
@@ -1,81 +0,0 @@
-# Copyright 2021 UC Davis Plant AI and Biophysics Lab
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import re
-import setuptools
-
-# ============== SETUP INFORMATION ==============
-
-with open(os.path.join(os.path.dirname(__file__), 'README.md'), 'r', encoding="utf-8") as f:
-    long_description = f.read()
-
-python_supported = ['3', '3.7', '3.8', '3.9', '3.10']
-os_supported = ['MacOS', 'Unix', 'POSIX', 'Microsoft :: Windows']
-
-CLASSIFIERS = [
-    "Development Status :: 3 - Alpha",
-    "Topic :: Scientific/Engineering",
-    *[f"Operating System :: {os}" for os in os_supported],
-    *[f"Programming Language :: Python :: {v}" for v in python_supported]
-]
-
-# ============ PACKAGE REQUIREMENTS =============
-
-with open(os.path.join(os.path.dirname(__file__), 'requirements.txt'), encoding="utf-8") as f:
-    install_requires = [line[:-1] for line in f.readlines() if line != '']
-
-tests_require = [
-    'pytest>=6.0.0',
-    'pytest-order==1.0.0'
-]
-
-dev_requires = [
-    'Shapely',
-    'semantics',
-    'scikit-image',
-    'boto3',
-    'botocore',
-    'pandas'
-] + tests_require
-
-# ==================== VERSIONING ====================
-
-with open(os.path.join(os.path.dirname(__file__), 'agml', '__init__.py'), 'r', encoding="utf-8") as f:
-    version = re.search(
-        r'^__version__ = [\'"]([^\'"]*)[\'"]', f.read(), re.M).group(1)
-
-# ==================== SETUP ====================
-    
-setuptools.setup(
-    name="agml",
-    version=version,
-    author="UC Davis Plant AI and Biophysics Lab",
-    author_email="jmearles@ucdavis.edu",
-    maintainer="Amogh Joshi",
-    maintainer_email="amnjoshi@ucdavis.edu",
-    url="https://github.com/plant-ai-biophysics-lab/AgML",
-    description="A comprehensive library for agricultural deep learning",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    packages=setuptools.find_packages(exclude = ('agml/_internal', )),
-    include_package_data=True,
-    classifiers=CLASSIFIERS,
-    install_requires=install_requires,
-    extras_require={
-        'dev': dev_requires,
-        'test': tests_require
-    }
-)
-
diff --git a/tests/data/test_dataloader_general.py b/tests/data/test_dataloader_general.py
index c53b99eb..b00e81b4 100644
--- a/tests/data/test_dataloader_general.py
+++ b/tests/data/test_dataloader_general.py
@@ -13,32 +13,33 @@
 # limitations under the License.
 
 import os
-import pytest
+
 import numpy as np
+import pytest
 
 import agml
 
 
 @pytest.mark.order(1)
 def test_loader_download_instantiation():
-    loader = agml.data.AgMLDataLoader('bean_disease_uganda')
+    loader = agml.data.AgMLDataLoader("bean_disease_uganda")
     assert os.path.exists(loader.dataset_root)
 
 
 @pytest.mark.order(2)
 def test_did_you_mean():
     with pytest.raises(ValueError) as exec_info:
-        agml.data.AgMLDataLoader('applefr_flower_zegmentation') # noqa
-    assert 'apple_flower_segmentation' in exec_info.value.args[0]
+        agml.data.AgMLDataLoader("applefr_flower_zegmentation")  # noqa
+    assert "apple_flower_segmentation" in exec_info.value.args[0]
     with pytest.raises(ValueError) as exec_info:
-        agml.data.AgMLDataLoader('eban_disge_ugandfea') # noqa
-    assert 'bean_disease_uganda' in exec_info.value.args[0]
+        agml.data.AgMLDataLoader("eban_disge_ugandfea")  # noqa
+    assert "bean_disease_uganda" in exec_info.value.args[0]
 
 
 @pytest.mark.order(3)
 def test_loader_split():
-    loader = agml.data.AgMLDataLoader('bean_disease_uganda')
-    loader.split(train = 0.7, val = 0.2, test = 0.1)
+    loader = agml.data.AgMLDataLoader("bean_disease_uganda")
+    loader.split(train=0.7, val=0.2, test=0.1)
     assert abs(len(loader.train_data) - int(0.7 * len(loader))) <= 1
     assert abs(len(loader.val_data) - int(0.2 * len(loader))) <= 1
     assert abs(len(loader.test_data) - int(0.1 * len(loader))) <= 1
@@ -46,32 +47,29 @@ def test_loader_split():
 
 @pytest.mark.order(4)
 def test_loader_split_save_and_load():
-    loader = agml.data.AgMLDataLoader('bean_disease_uganda')
-    loader.split(train = 0.7, val = 0.2, test = 0.1)
+    loader = agml.data.AgMLDataLoader("bean_disease_uganda")
+    loader.split(train=0.7, val=0.2, test=0.1)
     test_json = loader._test_content
-    loader.save_split('test_beans_split')
+    loader.save_split("test_beans_split")
 
-    new_loader = agml.data.AgMLDataLoader('bean_disease_uganda')
-    new_loader.load_split('test_beans_split')
+    new_loader = agml.data.AgMLDataLoader("bean_disease_uganda")
+    new_loader.load_split("test_beans_split")
     assert np.all(new_loader._test_content == test_json)
 
 
 @pytest.mark.order(5)
 def test_loader_batch():
-    loader = agml.data.AgMLDataLoader('apple_flower_segmentation')
+    loader = agml.data.AgMLDataLoader("apple_flower_segmentation")
     prev_length = len(loader)
-    loader.batch(batch_size = 1)
+    loader.batch(batch_size=1)
     assert len(loader) == prev_length
-    loader.batch(batch_size = 8)
+    loader.batch(batch_size=8)
     assert abs((len(loader) - prev_length // 8)) <= 1
 
 
 @pytest.mark.order(11)
 def test_loader_detection_shuffle():
-    loader = agml.data.AgMLDataLoader('apple_detection_usa')
+    loader = agml.data.AgMLDataLoader("apple_detection_usa")
     contents = loader._manager._accessors.copy()
     loader.shuffle()
     assert np.any(contents != loader._manager._accessors)
-
-
-
diff --git a/tests/data/test_format_tools.py b/tests/data/test_format_tools.py
index a0a809ad..cfeba005 100644
--- a/tests/data/test_format_tools.py
+++ b/tests/data/test_format_tools.py
@@ -12,55 +12,70 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import numpy as np
 import pytest
 
 import agml.data as agdata
-import numpy as np
 
 
 @pytest.fixture
 def coco_example():
     return [
         {
-            "area": 5472, "iscrowd": 0,
+            "area": 5472,
+            "iscrowd": 0,
             "bbox": [162, 648, 76, 72],
-            "category_id": 1, "ignore": 0,
-            "segmentation": [], "id": 4,
-            "image_id": 800
+            "category_id": 1,
+            "ignore": 0,
+            "segmentation": [],
+            "id": 4,
+            "image_id": 800,
         },
         {
-            "area": 10712, "iscrowd": 0,
+            "area": 10712,
+            "iscrowd": 0,
             "bbox": [1052, 547, 103, 104],
-            "category_id": 1, "ignore": 0,
-            "segmentation": [], "id": 5,
-            "image_id": 800
+            "category_id": 1,
+            "ignore": 0,
+            "segmentation": [],
+            "id": 5,
+            "image_id": 800,
         },
         {
-            "area": 13924, "iscrowd": 0,
+            "area": 13924,
+            "iscrowd": 0,
             "bbox": [1125, 560, 118, 118],
-            "category_id": 1, "ignore": 0,
-            "segmentation": [], "id": 6,
-            "image_id": 800
+            "category_id": 1,
+            "ignore": 0,
+            "segmentation": [],
+            "id": 6,
+            "image_id": 800,
         },
         {
-            "area": 10200, "iscrowd": 0,
+            "area": 10200,
+            "iscrowd": 0,
             "bbox": [456, 581, 100, 102],
-            "category_id": 1, "ignore": 0,
-            "segmentation": [], "id": 1,
-            "image_id": 801
+            "category_id": 1,
+            "ignore": 0,
+            "segmentation": [],
+            "id": 1,
+            "image_id": 801,
         },
         {
-            "area": 10584, "iscrowd": 0,
+            "area": 10584,
+            "iscrowd": 0,
             "bbox": [537, 598, 98, 108],
-            "category_id": 1, "ignore": 0,
-            "segmentation": [], "id": 2,
-            "image_id": 801
-        }
+            "category_id": 1,
+            "ignore": 0,
+            "segmentation": [],
+            "id": 2,
+            "image_id": 801,
+        },
     ]
 
 
 def test_coco_bbox_extraction(coco_example):
-    bboxes = [b['bbox'] for b in coco_example]
+    bboxes = [b["bbox"] for b in coco_example]
     assert agdata.coco_to_bboxes(coco_example)[0].tolist() == bboxes
 
 
@@ -69,14 +84,10 @@ def test_coco_formatting_rearrange(coco_example):
     og_bboxes = bboxes.copy()
     bboxes[:, [0, 2]] = bboxes[:, [2, 0]]
     bboxes[:, [1, 3]] = bboxes[:, [3, 1]]
-    assert np.all(agdata.convert_bbox_format(
-        bboxes, 'width height x1 y1') == og_bboxes)
+    assert np.all(agdata.convert_bbox_format(bboxes, "width height x1 y1") == og_bboxes)
 
 
 def test_coco_formatting_minmax():
     eg_box = [[100, 500, 200, 700]]
     eg_output = [[100, 200, 400, 500]]
-    assert np.all(agdata.convert_bbox_format(
-        eg_box, 'x1 x2 y1 y2') == eg_output)
-
-
+    assert np.all(agdata.convert_bbox_format(eg_box, "x1 x2 y1 y2") == eg_output)
diff --git a/tests/data/test_public_sources.py b/tests/data/test_public_sources.py
index 2923f432..3b0f5f42 100644
--- a/tests/data/test_public_sources.py
+++ b/tests/data/test_public_sources.py
@@ -13,8 +13,9 @@
 # limitations under the License.
 
 import os
-import time
 import shutil
+import time
+
 import pytest
 
 import agml.data as agdata
@@ -22,23 +23,21 @@
 
 
 def test_location_filters():
-    uganda_filter = agdata.public_data_sources(
-        location = 'country:uganda')
-    assert len(uganda_filter) == 1 and uganda_filter[0].name == 'bean_disease_uganda'
-    for source in agdata.public_data_sources(location = 'country:australia'):
-        assert source.location.continent == 'oceania'
+    uganda_filter = agdata.public_data_sources(location="country:uganda")
+    assert len(uganda_filter) == 1 and uganda_filter[0].name == "bean_disease_uganda"
+    for source in agdata.public_data_sources(location="country:australia"):
+        assert source.location.continent == "oceania"
 
 
 def test_num_images_filters():
-    for source in agdata.public_data_sources(n_images = '>1000'):
-        assert int(float(load_public_sources()[source.name]['n_images'])) >= 1000
+    for source in agdata.public_data_sources(n_images=">1000"):
+        assert int(float(load_public_sources()[source.name]["n_images"])) >= 1000
 
 
 def test_source_download():
-    local_path = os.path.join(
-        os.getcwd(), 'download_test')
-    agdata.download_public_dataset('bean_disease_uganda', local_path)
+    local_path = os.path.join(os.getcwd(), "download_test")
+    agdata.download_public_dataset("bean_disease_uganda", local_path)
     time.sleep(2)
-    assert os.path.exists(os.path.join(local_path, 'bean_disease_uganda'))
-    assert not os.path.exists(os.path.join(local_path, 'bean_disease_uganda.zip'))
+    assert os.path.exists(os.path.join(local_path, "bean_disease_uganda"))
+    assert not os.path.exists(os.path.join(local_path, "bean_disease_uganda.zip"))
     shutil.rmtree(os.path.join(local_path))
diff --git a/tests/main.py b/tests/main.py
index 2887597f..62561661 100644
--- a/tests/main.py
+++ b/tests/main.py
@@ -17,16 +17,19 @@
 
 import pytest
 
-BASE_PATH = os.path.join(os.path.expanduser('~'), '.agml', 'datasets')
-_USED_DATASETS = ['bean_disease_uganda', 'apple_flower_segmentation', 'apple_detection_usa']
+BASE_PATH = os.path.join(os.path.expanduser("~"), ".agml", "datasets")
+_USED_DATASETS = [
+    "bean_disease_uganda",
+    "apple_flower_segmentation",
+    "apple_detection_usa",
+]
 _PREEXISTING_DATASETS = []
 
 
 def _find_preexisting_datasets():
     global _USED_DATASETS, _PREEXISTING_DATASETS, BASE_PATH
     for dataset in _USED_DATASETS:
-        if os.path.exists(os.path.join(BASE_PATH, dataset)) \
-                and os.path.isdir(os.path.join(BASE_PATH, dataset)):
+        if os.path.exists(os.path.join(BASE_PATH, dataset)) and os.path.isdir(os.path.join(BASE_PATH, dataset)):
             _PREEXISTING_DATASETS.append(dataset)
 
 
@@ -51,5 +54,5 @@ def execute_tests():
     post_test_cleanup()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     execute_tests()
diff --git a/tests/test_import.py b/tests/test_import.py
new file mode 100644
index 00000000..f168c36d
--- /dev/null
+++ b/tests/test_import.py
@@ -0,0 +1,8 @@
+"""Test import."""
+
+
+def test_import():
+    """Test import only"""
+    import agml
+
+    assert agml.__version__ == "0.7.0"
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 00000000..d2b2ff8c
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,1685 @@
+version = 1
+requires-python = ">=3.8, <3.12"
+resolution-markers = [
+    "python_full_version < '3.9' and platform_machine == 'arm64' and platform_system == 'Darwin'",
+    "python_full_version < '3.9' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 'arm64') or (python_full_version < '3.9' and platform_machine == 'aarch64' and platform_system != 'Linux') or (python_full_version < '3.9' and platform_machine == 'arm64' and platform_system != 'Darwin')",
+    "python_full_version == '3.9.*' and platform_machine == 'arm64' and platform_system == 'Darwin'",
+    "python_full_version == '3.9.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 'arm64') or (python_full_version == '3.9.*' and platform_machine == 'aarch64' and platform_system != 'Linux') or (python_full_version == '3.9.*' and platform_machine == 'arm64' and platform_system != 'Darwin')",
+    "python_full_version == '3.10.*' and platform_system == 'Darwin'",
+    "python_full_version == '3.10.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version == '3.10.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.10.*' and platform_system != 'Darwin' and platform_system != 'Linux')",
+    "python_full_version >= '3.11' and platform_system == 'Darwin'",
+    "python_full_version >= '3.11' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version >= '3.11' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.11' and platform_system != 'Darwin' and platform_system != 'Linux')",
+]
+
+[[package]]
+name = "agml"
+version = "0.7.0"
+source = { editable = "." }
+dependencies = [
+    { name = "albumentations" },
+    { name = "dict2xml" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "opencv-python" },
+    { name = "opencv-python-headless" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "scikit-learn" },
+    { name = "tqdm" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "boto3" },
+    { name = "botocore" },
+    { name = "coverage" },
+    { name = "interrogate" },
+    { name = "mypy" },
+    { name = "pandas" },
+    { name = "pytest" },
+    { name = "pytest-cov" },
+    { name = "pytest-order" },
+    { name = "ruff" },
+    { name = "scikit-image" },
+    { name = "shapely" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "albumentations", specifier = ">=1.4.18" },
+    { name = "dict2xml", specifier = ">=1.7.6" },
+    { name = "matplotlib", specifier = ">=3.7.5" },
+    { name = "numpy", specifier = ">=1.24.4" },
+    { name = "opencv-python", specifier = ">=4.10.0.84" },
+    { name = "opencv-python-headless", specifier = ">=4.10.0.84" },
+    { name = "pyyaml", specifier = ">=6.0.2" },
+    { name = "requests", specifier = ">=2.0.0" },
+    { name = "scikit-learn", specifier = ">=1.3.2" },
+    { name = "tqdm", specifier = ">=4.67.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "boto3", specifier = ">=1.35.66" },
+    { name = "botocore", specifier = ">=1.35.66" },
+    { name = "coverage", specifier = ">=7.6.1" },
+    { name = "interrogate", specifier = ">=1.7.0" },
+    { name = "mypy", specifier = ">=1.13.0" },
+    { name = "pandas", specifier = ">=2.0.3" },
+    { name = "pytest", specifier = ">=8.3.3" },
+    { name = "pytest-cov", specifier = ">=5.0.0" },
+    { name = "pytest-order", specifier = ">=1.3.0" },
+    { name = "ruff", specifier = ">=0.7.4" },
+    { name = "scikit-image", specifier = ">=0.21.0" },
+    { name = "shapely", specifier = ">=2.0.6" },
+]
+
+[[package]]
+name = "albucore"
+version = "0.0.17"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "opencv-python-headless" },
+    { name = "typing-extensions", marker = "python_full_version < '3.10'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/03/81e5b3b6ee7911a70ed19028ccfed90f5cb32fc9fb33af5bc587fc1ab6a1/albucore-0.0.17.tar.gz", hash = "sha256:e9956ac4debc47e804f0677ff4e23939ba322986eac16e801f8ea1c98269db65", size = 12271 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/20/9f56b72131ea71c9566f0cc303a9e92156767845164c0f4ec10534630991/albucore-0.0.17-py3-none-any.whl", hash = "sha256:751a6d219a0b5217b44168d5fae90c27eadfa5bc381cbb7cc74536e90aeeac5b", size = 10378 },
+]
+
+[[package]]
+name = "albumentations"
+version = "1.4.18"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "albucore" },
+    { name = "eval-type-backport" },
+    { name = "numpy" },
+    { name = "opencv-python-headless" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "scikit-image" },
+    { name = "scipy" },
+    { name = "typing-extensions", marker = "python_full_version < '3.10'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/52/cd2399a7037a70dd6410a7c890a1cdfd79563c03c4a7f3311278c9a3b1b0/albumentations-1.4.18.tar.gz", hash = "sha256:701a9405f059f761f00ce00e187954d01276bdb78b33abcf864e79727db3bf1a", size = 207321 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/2f/468208ac3345b59286f5a73dd6e298c111c8a6a5896f658d221cd55ebf8d/albumentations-1.4.18-py3-none-any.whl", hash = "sha256:57ed0a634de9d3b34d003585aa90e9164e164ccc4ecb797eee8fbad8da1e9eaf", size = 224034 },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.9'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
+]
+
+[[package]]
+name = "attrs"
+version = "24.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/0f/aafca9af9315aee06a89ffde799a10a582fe8de76c563ee80bbcdc08b3fb/attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346", size = 792678 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/21/5b6702a7f963e95456c0de2d495f67bf5fd62840ac655dc451586d23d39a/attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2", size = 63001 },
+]
+
+[[package]]
+name = "boto3"
+version = "1.35.66"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+    { name = "jmespath" },
+    { name = "s3transfer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/aa/5a6318f61564bd181e6c65855dc78c46139b5e8c5e301256e18eedfbb7af/boto3-1.35.66.tar.gz", hash = "sha256:c392b9168b65e9c23483eaccb5b68d1f960232d7f967a1e00a045ba065ce050d", size = 111093 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/c8/fcf1ec25b0320af58be3a3d8c0f8ed06513133c65b318895e7eb39ef14ab/boto3-1.35.66-py3-none-any.whl", hash = "sha256:09a610f8cf4d3c22d4ca69c1f89079e3a1c82805ce94fa0eb4ecdd4d2ba6c4bc", size = 139191 },
+]
+
+[[package]]
+name = "botocore"
+version = "1.35.66"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jmespath" },
+    { name = "python-dateutil" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/87/06/bd0dcda686003598530eebbd0c4d7da67c031db2059a3d51a945e6199ce5/botocore-1.35.66.tar.gz", hash = "sha256:51f43220315f384959f02ea3266740db4d421592dd87576c18824e424b349fdb", size = 13089606 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/f0/372c2474cd198485ac427ccdd54796b05c2e730bdff0523c26012fe40ad7/botocore-1.35.66-py3-none-any.whl", hash = "sha256:d0683e9c18bb6852f768da268086c3749d925332a664db0dd1459cfa7e96e475", size = 12882983 },
+]
+
+[[package]]
+name = "certifi"
+version = "2024.8.30"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", size = 168507 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321 },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/8b/825cc84cf13a28bfbcba7c416ec22bf85a9584971be15b21dd8300c65b7f/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4f9fc98dad6c2eaa32fc3af1417d95b5e3d08aff968df0cd320066def971f9a6", size = 196363 },
+    { url = "https://files.pythonhosted.org/packages/23/81/d7eef6a99e42c77f444fdd7bc894b0ceca6c3a95c51239e74a722039521c/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0de7b687289d3c1b3e8660d0741874abe7888100efe14bd0f9fd7141bcbda92b", size = 125639 },
+    { url = "https://files.pythonhosted.org/packages/21/67/b4564d81f48042f520c948abac7079356e94b30cb8ffb22e747532cf469d/charset_normalizer-3.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ed2e36c3e9b4f21dd9422f6893dec0abf2cca553af509b10cd630f878d3eb99", size = 120451 },
+    { url = "https://files.pythonhosted.org/packages/c2/72/12a7f0943dd71fb5b4e7b55c41327ac0a1663046a868ee4d0d8e9c369b85/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca", size = 140041 },
+    { url = "https://files.pythonhosted.org/packages/67/56/fa28c2c3e31217c4c52158537a2cf5d98a6c1e89d31faf476c89391cd16b/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1110e22af8ca26b90bd6364fe4c763329b0ebf1ee213ba32b68c73de5752323d", size = 150333 },
+    { url = "https://files.pythonhosted.org/packages/f9/d2/466a9be1f32d89eb1554cf84073a5ed9262047acee1ab39cbaefc19635d2/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86f4e8cca779080f66ff4f191a685ced73d2f72d50216f7112185dc02b90b9b7", size = 142921 },
+    { url = "https://files.pythonhosted.org/packages/f8/01/344ec40cf5d85c1da3c1f57566c59e0c9b56bcc5566c08804a95a6cc8257/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f683ddc7eedd742e2889d2bfb96d69573fde1d92fcb811979cdb7165bb9c7d3", size = 144785 },
+    { url = "https://files.pythonhosted.org/packages/73/8b/2102692cb6d7e9f03b9a33a710e0164cadfce312872e3efc7cfe22ed26b4/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27623ba66c183eca01bf9ff833875b459cad267aeeb044477fedac35e19ba907", size = 146631 },
+    { url = "https://files.pythonhosted.org/packages/d8/96/cc2c1b5d994119ce9f088a9a0c3ebd489d360a2eb058e2c8049f27092847/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f606a1881d2663630ea5b8ce2efe2111740df4b687bd78b34a8131baa007f79b", size = 140867 },
+    { url = "https://files.pythonhosted.org/packages/c9/27/cde291783715b8ec30a61c810d0120411844bc4c23b50189b81188b273db/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0b309d1747110feb25d7ed6b01afdec269c647d382c857ef4663bbe6ad95a912", size = 149273 },
+    { url = "https://files.pythonhosted.org/packages/3a/a4/8633b0fc1a2d1834d5393dafecce4a1cc56727bfd82b4dc18fc92f0d3cc3/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:136815f06a3ae311fae551c3df1f998a1ebd01ddd424aa5603a4336997629e95", size = 152437 },
+    { url = "https://files.pythonhosted.org/packages/64/ea/69af161062166b5975ccbb0961fd2384853190c70786f288684490913bf5/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:14215b71a762336254351b00ec720a8e85cada43b987da5a042e4ce3e82bd68e", size = 150087 },
+    { url = "https://files.pythonhosted.org/packages/3b/fd/e60a9d9fd967f4ad5a92810138192f825d77b4fa2a557990fd575a47695b/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79983512b108e4a164b9c8d34de3992f76d48cadc9554c9e60b43f308988aabe", size = 145142 },
+    { url = "https://files.pythonhosted.org/packages/6d/02/8cb0988a1e49ac9ce2eed1e07b77ff118f2923e9ebd0ede41ba85f2dcb04/charset_normalizer-3.4.0-cp310-cp310-win32.whl", hash = "sha256:c94057af19bc953643a33581844649a7fdab902624d2eb739738a30e2b3e60fc", size = 94701 },
+    { url = "https://files.pythonhosted.org/packages/d6/20/f1d4670a8a723c46be695dff449d86d6092916f9e99c53051954ee33a1bc/charset_normalizer-3.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:55f56e2ebd4e3bc50442fbc0888c9d8c94e4e06a933804e2af3e89e2f9c1c749", size = 102191 },
+    { url = "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", size = 193339 },
+    { url = "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", size = 124366 },
+    { url = "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", size = 118874 },
+    { url = "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", size = 138243 },
+    { url = "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", size = 148676 },
+    { url = "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", size = 141289 },
+    { url = "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", size = 142585 },
+    { url = "https://files.pythonhosted.org/packages/3b/a0/a68980ab8a1f45a36d9745d35049c1af57d27255eff8c907e3add84cf68f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5", size = 144408 },
+    { url = "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", size = 139076 },
+    { url = "https://files.pythonhosted.org/packages/fb/9d/9c13753a5a6e0db4a0a6edb1cef7aee39859177b64e1a1e748a6e3ba62c2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c", size = 146874 },
+    { url = "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", size = 150871 },
+    { url = "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", size = 148546 },
+    { url = "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", size = 143048 },
+    { url = "https://files.pythonhosted.org/packages/01/f8/38842422988b795220eb8038745d27a675ce066e2ada79516c118f291f07/charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99", size = 94389 },
+    { url = "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", size = 101752 },
+    { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 },
+    { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 },
+    { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 },
+    { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 },
+    { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 },
+    { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 },
+    { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 },
+    { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 },
+    { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 },
+    { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 },
+    { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 },
+    { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 },
+    { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 },
+    { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836 },
+    { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187 },
+    { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 },
+    { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 },
+    { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342 },
+    { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383 },
+    { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214 },
+    { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104 },
+    { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255 },
+    { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251 },
+    { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474 },
+    { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849 },
+    { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781 },
+    { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970 },
+    { url = "https://files.pythonhosted.org/packages/cc/67/e5e7e0cbfefc4ca79025238b43cdf8a2037854195b37d6417f3d0895c4c2/charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67", size = 94973 },
+    { url = "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", size = 102308 },
+    { url = "https://files.pythonhosted.org/packages/86/f4/ccab93e631e7293cca82f9f7ba39783c967f823a0000df2d8dd743cad74f/charset_normalizer-3.4.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:af73657b7a68211996527dbfeffbb0864e043d270580c5aef06dc4b659a4b578", size = 193961 },
+    { url = "https://files.pythonhosted.org/packages/94/d4/2b21cb277bac9605026d2d91a4a8872bc82199ed11072d035dc674c27223/charset_normalizer-3.4.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:cab5d0b79d987c67f3b9e9c53f54a61360422a5a0bc075f43cab5621d530c3b6", size = 124507 },
+    { url = "https://files.pythonhosted.org/packages/9a/e0/a7c1fcdff20d9c667342e0391cfeb33ab01468d7d276b2c7914b371667cc/charset_normalizer-3.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9289fd5dddcf57bab41d044f1756550f9e7cf0c8e373b8cdf0ce8773dc4bd417", size = 119298 },
+    { url = "https://files.pythonhosted.org/packages/70/de/1538bb2f84ac9940f7fa39945a5dd1d22b295a89c98240b262fc4b9fcfe0/charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b493a043635eb376e50eedf7818f2f322eabbaa974e948bd8bdd29eb7ef2a51", size = 139328 },
+    { url = "https://files.pythonhosted.org/packages/e9/ca/288bb1a6bc2b74fb3990bdc515012b47c4bc5925c8304fc915d03f94b027/charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fa2566ca27d67c86569e8c85297aaf413ffab85a8960500f12ea34ff98e4c41", size = 149368 },
+    { url = "https://files.pythonhosted.org/packages/aa/75/58374fdaaf8406f373e508dab3486a31091f760f99f832d3951ee93313e8/charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8e538f46104c815be19c975572d74afb53f29650ea2025bbfaef359d2de2f7f", size = 141944 },
+    { url = "https://files.pythonhosted.org/packages/32/c8/0bc558f7260db6ffca991ed7166494a7da4fda5983ee0b0bfc8ed2ac6ff9/charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fd30dc99682dc2c603c2b315bded2799019cea829f8bf57dc6b61efde6611c8", size = 143326 },
+    { url = "https://files.pythonhosted.org/packages/0e/dd/7f6fec09a1686446cee713f38cf7d5e0669e0bcc8288c8e2924e998cf87d/charset_normalizer-3.4.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2006769bd1640bdf4d5641c69a3d63b71b81445473cac5ded39740a226fa88ab", size = 146171 },
+    { url = "https://files.pythonhosted.org/packages/4c/a8/440f1926d6d8740c34d3ca388fbd718191ec97d3d457a0677eb3aa718fce/charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:dc15e99b2d8a656f8e666854404f1ba54765871104e50c8e9813af8a7db07f12", size = 139711 },
+    { url = "https://files.pythonhosted.org/packages/e9/7f/4b71e350a3377ddd70b980bea1e2cc0983faf45ba43032b24b2578c14314/charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:ab2e5bef076f5a235c3774b4f4028a680432cded7cad37bba0fd90d64b187d19", size = 148348 },
+    { url = "https://files.pythonhosted.org/packages/1e/70/17b1b9202531a33ed7ef41885f0d2575ae42a1e330c67fddda5d99ad1208/charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:4ec9dd88a5b71abfc74e9df5ebe7921c35cbb3b641181a531ca65cdb5e8e4dea", size = 151290 },
+    { url = "https://files.pythonhosted.org/packages/44/30/574b5b5933d77ecb015550aafe1c7d14a8cd41e7e6c4dcea5ae9e8d496c3/charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:43193c5cda5d612f247172016c4bb71251c784d7a4d9314677186a838ad34858", size = 149114 },
+    { url = "https://files.pythonhosted.org/packages/0b/11/ca7786f7e13708687443082af20d8341c02e01024275a28bc75032c5ce5d/charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:aa693779a8b50cd97570e5a0f343538a8dbd3e496fa5dcb87e29406ad0299654", size = 143856 },
+    { url = "https://files.pythonhosted.org/packages/f9/c2/1727c1438256c71ed32753b23ec2e6fe7b6dff66a598f6566cfe8139305e/charset_normalizer-3.4.0-cp38-cp38-win32.whl", hash = "sha256:7706f5850360ac01d80c89bcef1640683cc12ed87f42579dab6c5d3ed6888613", size = 94333 },
+    { url = "https://files.pythonhosted.org/packages/09/c8/0e17270496a05839f8b500c1166e3261d1226e39b698a735805ec206967b/charset_normalizer-3.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:c3e446d253bd88f6377260d07c895816ebf33ffffd56c1c792b13bff9c3e1ade", size = 101454 },
+    { url = "https://files.pythonhosted.org/packages/54/2f/28659eee7f5d003e0f5a3b572765bf76d6e0fe6601ab1f1b1dd4cba7e4f1/charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:980b4f289d1d90ca5efcf07958d3eb38ed9c0b7676bf2831a54d4f66f9c27dfa", size = 196326 },
+    { url = "https://files.pythonhosted.org/packages/d1/18/92869d5c0057baa973a3ee2af71573be7b084b3c3d428fe6463ce71167f8/charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f28f891ccd15c514a0981f3b9db9aa23d62fe1a99997512b0491d2ed323d229a", size = 125614 },
+    { url = "https://files.pythonhosted.org/packages/d6/27/327904c5a54a7796bb9f36810ec4173d2df5d88b401d2b95ef53111d214e/charset_normalizer-3.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8aacce6e2e1edcb6ac625fb0f8c3a9570ccc7bfba1f63419b3769ccf6a00ed0", size = 120450 },
+    { url = "https://files.pythonhosted.org/packages/a4/23/65af317914a0308495133b2d654cf67b11bbd6ca16637c4e8a38f80a5a69/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd7af3717683bea4c87acd8c0d3d5b44d56120b26fd3f8a692bdd2d5260c620a", size = 140135 },
+    { url = "https://files.pythonhosted.org/packages/f2/41/6190102ad521a8aa888519bb014a74251ac4586cde9b38e790901684f9ab/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ff2ed8194587faf56555927b3aa10e6fb69d931e33953943bc4f837dfee2242", size = 150413 },
+    { url = "https://files.pythonhosted.org/packages/7b/ab/f47b0159a69eab9bd915591106859f49670c75f9a19082505ff16f50efc0/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e91f541a85298cf35433bf66f3fab2a4a2cff05c127eeca4af174f6d497f0d4b", size = 142992 },
+    { url = "https://files.pythonhosted.org/packages/28/89/60f51ad71f63aaaa7e51a2a2ad37919985a341a1d267070f212cdf6c2d22/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:309a7de0a0ff3040acaebb35ec45d18db4b28232f21998851cfa709eeff49d62", size = 144871 },
+    { url = "https://files.pythonhosted.org/packages/0c/48/0050550275fea585a6e24460b42465020b53375017d8596c96be57bfabca/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:285e96d9d53422efc0d7a17c60e59f37fbf3dfa942073f666db4ac71e8d726d0", size = 146756 },
+    { url = "https://files.pythonhosted.org/packages/dc/b5/47f8ee91455946f745e6c9ddbb0f8f50314d2416dd922b213e7d5551ad09/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5d447056e2ca60382d460a604b6302d8db69476fd2015c81e7c35417cfabe4cd", size = 141034 },
+    { url = "https://files.pythonhosted.org/packages/84/79/5c731059ebab43e80bf61fa51666b9b18167974b82004f18c76378ed31a3/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:20587d20f557fe189b7947d8e7ec5afa110ccf72a3128d61a2a387c3313f46be", size = 149434 },
+    { url = "https://files.pythonhosted.org/packages/ca/f3/0719cd09fc4dc42066f239cb3c48ced17fc3316afca3e2a30a4756fe49ab/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:130272c698667a982a5d0e626851ceff662565379baf0ff2cc58067b81d4f11d", size = 152443 },
+    { url = "https://files.pythonhosted.org/packages/f7/0e/c6357297f1157c8e8227ff337e93fd0a90e498e3d6ab96b2782204ecae48/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:ab22fbd9765e6954bc0bcff24c25ff71dcbfdb185fcdaca49e81bac68fe724d3", size = 150294 },
+    { url = "https://files.pythonhosted.org/packages/54/9a/acfa96dc4ea8c928040b15822b59d0863d6e1757fba8bd7de3dc4f761c13/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7782afc9b6b42200f7362858f9e73b1f8316afb276d316336c0ec3bd73312742", size = 145314 },
+    { url = "https://files.pythonhosted.org/packages/73/1c/b10a63032eaebb8d7bcb8544f12f063f41f5f463778ac61da15d9985e8b6/charset_normalizer-3.4.0-cp39-cp39-win32.whl", hash = "sha256:2de62e8801ddfff069cd5c504ce3bc9672b23266597d4e4f50eda28846c322f2", size = 94724 },
+    { url = "https://files.pythonhosted.org/packages/c5/77/3a78bf28bfaa0863f9cfef278dbeadf55efe064eafff8c7c424ae3c4c1bf/charset_normalizer-3.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:95c3c157765b031331dd4db3c775e58deaee050a3042fcad72cbc4189d7c8dca", size = 102159 },
+    { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446 },
+]
+
+[[package]]
+name = "click"
+version = "8.1.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "platform_system == 'Windows'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/d3/f04c7bfcf5c1862a2a5b845c6b2b360488cf47af55dfa79c98f6a6bf98b5/click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de", size = 336121 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28", size = 97941 },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/7d/087ee4295e7580d3f7eb8a8a4e0ec8c7847e60f34135248ccf831cf5bbfc/contourpy-1.1.1.tar.gz", hash = "sha256:96ba37c2e24b7212a77da85004c38e7c4d155d3e72a45eeaf22c1f03f607e8ab", size = 13433167 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/7f/c44a51a83a093bf5c84e07dd1e3cfe9f68c47b6499bd05a9de0c6dbdc2bc/contourpy-1.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:46e24f5412c948d81736509377e255f6040e94216bf1a9b5ea1eaa9d29f6ec1b", size = 247207 },
+    { url = "https://files.pythonhosted.org/packages/a9/65/544d66da0716b20084874297ff7596704e435cf011512f8e576638e83db2/contourpy-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e48694d6a9c5a26ee85b10130c77a011a4fedf50a7279fa0bdaf44bafb4299d", size = 232428 },
+    { url = "https://files.pythonhosted.org/packages/5b/e6/697085cc34a294bd399548fd99562537a75408f113e3a815807e206246f0/contourpy-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a66045af6cf00e19d02191ab578a50cb93b2028c3eefed999793698e9ea768ae", size = 285304 },
+    { url = "https://files.pythonhosted.org/packages/69/4b/52d0d2e85c59f00f6ddbd6fea819f267008c58ee7708da96d112a293e91c/contourpy-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ebf42695f75ee1a952f98ce9775c873e4971732a87334b099dde90b6af6a916", size = 322655 },
+    { url = "https://files.pythonhosted.org/packages/82/fc/3decc656a547a6d5d5b4249f81c72668a1f3259a62b2def2504120d38746/contourpy-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6aec19457617ef468ff091669cca01fa7ea557b12b59a7908b9474bb9674cf0", size = 296430 },
+    { url = "https://files.pythonhosted.org/packages/f1/6b/e4b0f8708f22dd7c321f87eadbb98708975e115ac6582eb46d1f32197ce6/contourpy-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:462c59914dc6d81e0b11f37e560b8a7c2dbab6aca4f38be31519d442d6cde1a1", size = 301672 },
+    { url = "https://files.pythonhosted.org/packages/c3/87/201410522a756e605069078833d806147cad8532fdc164a96689d05c5afc/contourpy-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6d0a8efc258659edc5299f9ef32d8d81de8b53b45d67bf4bfa3067f31366764d", size = 820145 },
+    { url = "https://files.pythonhosted.org/packages/b4/d9/42680a17d43edda04ab2b3f11125cf97b61bce5d3b52721a42960bf748bd/contourpy-1.1.1-cp310-cp310-win32.whl", hash = "sha256:d6ab42f223e58b7dac1bb0af32194a7b9311065583cc75ff59dcf301afd8a431", size = 399542 },
+    { url = "https://files.pythonhosted.org/packages/55/14/0dc1884e3c04f9b073a47283f5d424926644250891db392a07c56f05e5c5/contourpy-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:549174b0713d49871c6dee90a4b499d3f12f5e5f69641cd23c50a4542e2ca1eb", size = 477974 },
+    { url = "https://files.pythonhosted.org/packages/8b/4f/be28a39cd5e988b8d3c2cc642c2c7ffeeb28fe80a86df71b6d1e473c5038/contourpy-1.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:407d864db716a067cc696d61fa1ef6637fedf03606e8417fe2aeed20a061e6b2", size = 248613 },
+    { url = "https://files.pythonhosted.org/packages/2c/8e/656f8e7cd316aa68d9824744773e90dbd71f847429d10c82001e927480a2/contourpy-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe80c017973e6a4c367e037cb31601044dd55e6bfacd57370674867d15a899b", size = 233603 },
+    { url = "https://files.pythonhosted.org/packages/60/2a/4d4bd4541212ab98f3411f21bf58b0b246f333ae996e9f57e1acf12bcc45/contourpy-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e30aaf2b8a2bac57eb7e1650df1b3a4130e8d0c66fc2f861039d507a11760e1b", size = 287037 },
+    { url = "https://files.pythonhosted.org/packages/24/67/8abf919443381585a4eee74069e311c736350549dae02d3d014fef93d50a/contourpy-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3de23ca4f381c3770dee6d10ead6fff524d540c0f662e763ad1530bde5112532", size = 323274 },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6da11329dd35a2f2e404a95e5374b5702de6ac52e776e8b87dd6ea4b29d0/contourpy-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:566f0e41df06dfef2431defcfaa155f0acfa1ca4acbf8fd80895b1e7e2ada40e", size = 297801 },
+    { url = "https://files.pythonhosted.org/packages/b7/f6/78f60fa0b6ae64971178e2542e8b3ad3ba5f4f379b918ab7b18038a3f897/contourpy-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b04c2f0adaf255bf756cf08ebef1be132d3c7a06fe6f9877d55640c5e60c72c5", size = 302821 },
+    { url = "https://files.pythonhosted.org/packages/da/25/6062395a1c6a06f46a577da821318886b8b939453a098b9cd61671bb497b/contourpy-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d0c188ae66b772d9d61d43c6030500344c13e3f73a00d1dc241da896f379bb62", size = 820121 },
+    { url = "https://files.pythonhosted.org/packages/41/5e/64e78b1e8682cbab10c13fc1a2c070d30acedb805ab2f42afbd3d88f7225/contourpy-1.1.1-cp311-cp311-win32.whl", hash = "sha256:0683e1ae20dc038075d92e0e0148f09ffcefab120e57f6b4c9c0f477ec171f33", size = 401590 },
+    { url = "https://files.pythonhosted.org/packages/e5/76/94bc17eb868f8c7397f8fdfdeae7661c1b9a35f3a7219da308596e8c252a/contourpy-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:8636cd2fc5da0fb102a2504fa2c4bea3cbc149533b345d72cdf0e7a924decc45", size = 480534 },
+    { url = "https://files.pythonhosted.org/packages/94/0f/07a5e26fec7176658f6aecffc615900ff1d303baa2b67bc37fd98ce67c87/contourpy-1.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:560f1d68a33e89c62da5da4077ba98137a5e4d3a271b29f2f195d0fba2adcb6a", size = 249799 },
+    { url = "https://files.pythonhosted.org/packages/32/0b/d7baca3f60d3b3a77c9ba1307c7792befd3c1c775a26c649dca1bfa9b6ba/contourpy-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:24216552104ae8f3b34120ef84825400b16eb6133af2e27a190fdc13529f023e", size = 232739 },
+    { url = "https://files.pythonhosted.org/packages/6d/62/a385b4d4b5718e3a933de5791528f45f1f5b364d3c79172ad0309c832041/contourpy-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56de98a2fb23025882a18b60c7f0ea2d2d70bbbcfcf878f9067234b1c4818442", size = 282171 },
+    { url = "https://files.pythonhosted.org/packages/91/21/8c6819747fea53557f3963ca936035b3e8bed87d591f5278ad62516a059d/contourpy-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:07d6f11dfaf80a84c97f1a5ba50d129d9303c5b4206f776e94037332e298dda8", size = 321182 },
+    { url = "https://files.pythonhosted.org/packages/22/29/d75da9002f9df09c755b12cf0357eb91b081c858e604f4e92b4b8bfc3c15/contourpy-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1eaac5257a8f8a047248d60e8f9315c6cff58f7803971170d952555ef6344a7", size = 295869 },
+    { url = "https://files.pythonhosted.org/packages/a7/47/4e7e66159f881c131e3b97d1cc5c0ea72be62bdd292c7f63fd13937d07f4/contourpy-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19557fa407e70f20bfaba7d55b4d97b14f9480856c4fb65812e8a05fe1c6f9bf", size = 298756 },
+    { url = "https://files.pythonhosted.org/packages/d3/bb/bffc99bc3172942b5eda8027ca0cb80ddd336fcdd634d68adce957d37231/contourpy-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:081f3c0880712e40effc5f4c3b08feca6d064cb8cfbb372ca548105b86fd6c3d", size = 818441 },
+    { url = "https://files.pythonhosted.org/packages/da/1b/904baf0aaaf6c6e2247801dcd1ff0d7bf84352839927d356b28ae804cbb0/contourpy-1.1.1-cp312-cp312-win32.whl", hash = "sha256:059c3d2a94b930f4dafe8105bcdc1b21de99b30b51b5bce74c753686de858cb6", size = 410294 },
+    { url = "https://files.pythonhosted.org/packages/75/d4/c3b7a9a0d1f99b528e5a46266b0b9f13aad5a0dd1156d071418df314c427/contourpy-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f44d78b61740e4e8c71db1cf1fd56d9050a4747681c59ec1094750a658ceb970", size = 486678 },
+    { url = "https://files.pythonhosted.org/packages/02/7e/ffaba1bf3719088be3ad6983a5e85e1fc9edccd7b406b98e433436ecef74/contourpy-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:70e5a10f8093d228bb2b552beeb318b8928b8a94763ef03b858ef3612b29395d", size = 247023 },
+    { url = "https://files.pythonhosted.org/packages/a6/82/29f5ff4ae074c3230e266bc9efef449ebde43721a727b989dd8ef8f97d73/contourpy-1.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8394e652925a18ef0091115e3cc191fef350ab6dc3cc417f06da66bf98071ae9", size = 232380 },
+    { url = "https://files.pythonhosted.org/packages/9b/cb/08f884c4c2efd433a38876b1b8069bfecef3f2d21ff0ce635d455962f70f/contourpy-1.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5bd5680f844c3ff0008523a71949a3ff5e4953eb7701b28760805bc9bcff217", size = 285830 },
+    { url = "https://files.pythonhosted.org/packages/8e/57/cd4d4c99d999a25e9d518f628b4793e64b1ecb8ad3147f8469d8d4a80678/contourpy-1.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66544f853bfa85c0d07a68f6c648b2ec81dafd30f272565c37ab47a33b220684", size = 322038 },
+    { url = "https://files.pythonhosted.org/packages/32/b6/c57ed305a6f86731107fc183e97c7e6a6005d145f5c5228a44718082ad12/contourpy-1.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0c02b75acfea5cab07585d25069207e478d12309557f90a61b5a3b4f77f46ce", size = 295797 },
+    { url = "https://files.pythonhosted.org/packages/8e/71/7f20855592cc929bc206810432b991ec4c702dc26b0567b132e52c85536f/contourpy-1.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41339b24471c58dc1499e56783fedc1afa4bb018bcd035cfb0ee2ad2a7501ef8", size = 301124 },
+    { url = "https://files.pythonhosted.org/packages/86/6d/52c2fc80f433e7cdc8624d82e1422ad83ad461463cf16a1953bbc7d10eb1/contourpy-1.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f29fb0b3f1217dfe9362ec55440d0743fe868497359f2cf93293f4b2701b8251", size = 819787 },
+    { url = "https://files.pythonhosted.org/packages/d0/b0/f8d4548e89f929d6c5ca329df9afad6190af60079ec77d8c31eb48cf6f82/contourpy-1.1.1-cp38-cp38-win32.whl", hash = "sha256:f9dc7f933975367251c1b34da882c4f0e0b2e24bb35dc906d2f598a40b72bfc7", size = 400031 },
+    { url = "https://files.pythonhosted.org/packages/96/1b/b05cd42c8d21767a0488b883b38658fb9a45f86c293b7b42521a8113dc5d/contourpy-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:498e53573e8b94b1caeb9e62d7c2d053c263ebb6aa259c81050766beb50ff8d9", size = 477949 },
+    { url = "https://files.pythonhosted.org/packages/16/d9/8a15ff67fc27c65939e454512955e1b240ec75cd201d82e115b3b63ef76d/contourpy-1.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ba42e3810999a0ddd0439e6e5dbf6d034055cdc72b7c5c839f37a7c274cb4eba", size = 247396 },
+    { url = "https://files.pythonhosted.org/packages/09/fe/086e6847ee53da10ddf0b6c5e5f877ab43e68e355d2f4c85f67561ee8a57/contourpy-1.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6c06e4c6e234fcc65435223c7b2a90f286b7f1b2733058bdf1345d218cc59e34", size = 232598 },
+    { url = "https://files.pythonhosted.org/packages/a3/9c/662925239e1185c6cf1da8c334e4c61bddcfa8e528f4b51083b613003170/contourpy-1.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca6fab080484e419528e98624fb5c4282148b847e3602dc8dbe0cb0669469887", size = 286436 },
+    { url = "https://files.pythonhosted.org/packages/d3/7e/417cdf65da7140981079eda6a81ecd593ae0239bf8c738f2e2b3f6df8920/contourpy-1.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:93df44ab351119d14cd1e6b52a5063d3336f0754b72736cc63db59307dabb718", size = 322629 },
+    { url = "https://files.pythonhosted.org/packages/a8/22/ffd88aef74cc045698c5e5c400e8b7cd62311199c109245ac7827290df2c/contourpy-1.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eafbef886566dc1047d7b3d4b14db0d5b7deb99638d8e1be4e23a7c7ac59ff0f", size = 297117 },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/24c34c41a180f875419b536125799c61e2330b997d77a5a818a3bc3e08cd/contourpy-1.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efe0fab26d598e1ec07d72cf03eaeeba8e42b4ecf6b9ccb5a356fde60ff08b85", size = 301855 },
+    { url = "https://files.pythonhosted.org/packages/bf/ec/f9877f6378a580cd683bd76c8a781dcd972e82965e0da951a739d3364677/contourpy-1.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f08e469821a5e4751c97fcd34bcb586bc243c39c2e39321822060ba902eac49e", size = 820597 },
+    { url = "https://files.pythonhosted.org/packages/e1/3a/c41f4bc7122d3a06388acae1bed6f50a665c1031863ca42bd701094dcb1f/contourpy-1.1.1-cp39-cp39-win32.whl", hash = "sha256:bfc8a5e9238232a45ebc5cb3bfee71f1167064c8d382cadd6076f0d51cff1da0", size = 400031 },
+    { url = "https://files.pythonhosted.org/packages/87/2b/9b49451f7412cc1a79198e94a771a4e52d65c479aae610b1161c0290ef2c/contourpy-1.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:c84fdf3da00c2827d634de4fcf17e3e067490c4aea82833625c4c8e6cdea0887", size = 435965 },
+    { url = "https://files.pythonhosted.org/packages/e6/3c/fc36884b6793e2066a6ff25c86e21b8bd62553456b07e964c260bcf22711/contourpy-1.1.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:229a25f68046c5cf8067d6d6351c8b99e40da11b04d8416bf8d2b1d75922521e", size = 246493 },
+    { url = "https://files.pythonhosted.org/packages/3d/85/f4c5b09ce79828ed4553a8ae2ebdf937794f57b45848b1f5c95d9744ecc2/contourpy-1.1.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a10dab5ea1bd4401c9483450b5b0ba5416be799bbd50fc7a6cc5e2a15e03e8a3", size = 289240 },
+    { url = "https://files.pythonhosted.org/packages/18/d3/9d7c0a372baf5130c1417a4b8275079d5379c11355436cb9fc78af7d7559/contourpy-1.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4f9147051cb8fdb29a51dc2482d792b3b23e50f8f57e3720ca2e3d438b7adf23", size = 476043 },
+    { url = "https://files.pythonhosted.org/packages/e7/12/643242c3d9b031ca19f9a440f63e568dd883a04711056ca5d607f9bda888/contourpy-1.1.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a75cc163a5f4531a256f2c523bd80db509a49fc23721b36dd1ef2f60ff41c3cb", size = 246247 },
+    { url = "https://files.pythonhosted.org/packages/e1/37/95716fe235bf441422059e4afcd4b9b7c5821851c2aee992a06d1e9f831a/contourpy-1.1.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b53d5769aa1f2d4ea407c65f2d1d08002952fac1d9e9d307aa2e1023554a163", size = 289029 },
+    { url = "https://files.pythonhosted.org/packages/e5/fd/14852c4a688031e0d8a20d9a1b60078d45507186ef17042093835be2f01a/contourpy-1.1.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11b836b7dbfb74e049c302bbf74b4b8f6cb9d0b6ca1bf86cfa8ba144aedadd9c", size = 476043 },
+]
+
+[[package]]
+name = "coverage"
+version = "7.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/08/7e37f82e4d1aead42a7443ff06a1e406aabf7302c4f00a546e4b320b994c/coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d", size = 798791 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/61/eb7ce5ed62bacf21beca4937a90fe32545c91a3c8a42a30c6616d48fc70d/coverage-7.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b06079abebbc0e89e6163b8e8f0e16270124c154dc6e4a47b413dd538859af16", size = 206690 },
+    { url = "https://files.pythonhosted.org/packages/7d/73/041928e434442bd3afde5584bdc3f932fb4562b1597629f537387cec6f3d/coverage-7.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cf4b19715bccd7ee27b6b120e7e9dd56037b9c0681dcc1adc9ba9db3d417fa36", size = 207127 },
+    { url = "https://files.pythonhosted.org/packages/c7/c8/6ca52b5147828e45ad0242388477fdb90df2c6cbb9a441701a12b3c71bc8/coverage-7.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61c0abb4c85b095a784ef23fdd4aede7a2628478e7baba7c5e3deba61070a02", size = 235654 },
+    { url = "https://files.pythonhosted.org/packages/d5/da/9ac2b62557f4340270942011d6efeab9833648380109e897d48ab7c1035d/coverage-7.6.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd21f6ae3f08b41004dfb433fa895d858f3f5979e7762d052b12aef444e29afc", size = 233598 },
+    { url = "https://files.pythonhosted.org/packages/53/23/9e2c114d0178abc42b6d8d5281f651a8e6519abfa0ef460a00a91f80879d/coverage-7.6.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f59d57baca39b32db42b83b2a7ba6f47ad9c394ec2076b084c3f029b7afca23", size = 234732 },
+    { url = "https://files.pythonhosted.org/packages/0f/7e/a0230756fb133343a52716e8b855045f13342b70e48e8ad41d8a0d60ab98/coverage-7.6.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a1ac0ae2b8bd743b88ed0502544847c3053d7171a3cff9228af618a068ed9c34", size = 233816 },
+    { url = "https://files.pythonhosted.org/packages/28/7c/3753c8b40d232b1e5eeaed798c875537cf3cb183fb5041017c1fdb7ec14e/coverage-7.6.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e6a08c0be454c3b3beb105c0596ebdc2371fab6bb90c0c0297f4e58fd7e1012c", size = 232325 },
+    { url = "https://files.pythonhosted.org/packages/57/e3/818a2b2af5b7573b4b82cf3e9f137ab158c90ea750a8f053716a32f20f06/coverage-7.6.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f5796e664fe802da4f57a168c85359a8fbf3eab5e55cd4e4569fbacecc903959", size = 233418 },
+    { url = "https://files.pythonhosted.org/packages/c8/fb/4532b0b0cefb3f06d201648715e03b0feb822907edab3935112b61b885e2/coverage-7.6.1-cp310-cp310-win32.whl", hash = "sha256:7bb65125fcbef8d989fa1dd0e8a060999497629ca5b0efbca209588a73356232", size = 209343 },
+    { url = "https://files.pythonhosted.org/packages/5a/25/af337cc7421eca1c187cc9c315f0a755d48e755d2853715bfe8c418a45fa/coverage-7.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:3115a95daa9bdba70aea750db7b96b37259a81a709223c8448fa97727d546fe0", size = 210136 },
+    { url = "https://files.pythonhosted.org/packages/ad/5f/67af7d60d7e8ce61a4e2ddcd1bd5fb787180c8d0ae0fbd073f903b3dd95d/coverage-7.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7dea0889685db8550f839fa202744652e87c60015029ce3f60e006f8c4462c93", size = 206796 },
+    { url = "https://files.pythonhosted.org/packages/e1/0e/e52332389e057daa2e03be1fbfef25bb4d626b37d12ed42ae6281d0a274c/coverage-7.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed37bd3c3b063412f7620464a9ac1314d33100329f39799255fb8d3027da50d3", size = 207244 },
+    { url = "https://files.pythonhosted.org/packages/aa/cd/766b45fb6e090f20f8927d9c7cb34237d41c73a939358bc881883fd3a40d/coverage-7.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d85f5e9a5f8b73e2350097c3756ef7e785f55bd71205defa0bfdaf96c31616ff", size = 239279 },
+    { url = "https://files.pythonhosted.org/packages/70/6c/a9ccd6fe50ddaf13442a1e2dd519ca805cbe0f1fcd377fba6d8339b98ccb/coverage-7.6.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bc572be474cafb617672c43fe989d6e48d3c83af02ce8de73fff1c6bb3c198d", size = 236859 },
+    { url = "https://files.pythonhosted.org/packages/14/6f/8351b465febb4dbc1ca9929505202db909c5a635c6fdf33e089bbc3d7d85/coverage-7.6.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0420b573964c760df9e9e86d1a9a622d0d27f417e1a949a8a66dd7bcee7bc6", size = 238549 },
+    { url = "https://files.pythonhosted.org/packages/68/3c/289b81fa18ad72138e6d78c4c11a82b5378a312c0e467e2f6b495c260907/coverage-7.6.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1f4aa8219db826ce6be7099d559f8ec311549bfc4046f7f9fe9b5cea5c581c56", size = 237477 },
+    { url = "https://files.pythonhosted.org/packages/ed/1c/aa1efa6459d822bd72c4abc0b9418cf268de3f60eeccd65dc4988553bd8d/coverage-7.6.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:fc5a77d0c516700ebad189b587de289a20a78324bc54baee03dd486f0855d234", size = 236134 },
+    { url = "https://files.pythonhosted.org/packages/fb/c8/521c698f2d2796565fe9c789c2ee1ccdae610b3aa20b9b2ef980cc253640/coverage-7.6.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b48f312cca9621272ae49008c7f613337c53fadca647d6384cc129d2996d1133", size = 236910 },
+    { url = "https://files.pythonhosted.org/packages/7d/30/033e663399ff17dca90d793ee8a2ea2890e7fdf085da58d82468b4220bf7/coverage-7.6.1-cp311-cp311-win32.whl", hash = "sha256:1125ca0e5fd475cbbba3bb67ae20bd2c23a98fac4e32412883f9bcbaa81c314c", size = 209348 },
+    { url = "https://files.pythonhosted.org/packages/20/05/0d1ccbb52727ccdadaa3ff37e4d2dc1cd4d47f0c3df9eb58d9ec8508ca88/coverage-7.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:8ae539519c4c040c5ffd0632784e21b2f03fc1340752af711f33e5be83a9d6c6", size = 210230 },
+    { url = "https://files.pythonhosted.org/packages/7e/d4/300fc921dff243cd518c7db3a4c614b7e4b2431b0d1145c1e274fd99bd70/coverage-7.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:95cae0efeb032af8458fc27d191f85d1717b1d4e49f7cb226cf526ff28179778", size = 206983 },
+    { url = "https://files.pythonhosted.org/packages/e1/ab/6bf00de5327ecb8db205f9ae596885417a31535eeda6e7b99463108782e1/coverage-7.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5621a9175cf9d0b0c84c2ef2b12e9f5f5071357c4d2ea6ca1cf01814f45d2391", size = 207221 },
+    { url = "https://files.pythonhosted.org/packages/92/8f/2ead05e735022d1a7f3a0a683ac7f737de14850395a826192f0288703472/coverage-7.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:260933720fdcd75340e7dbe9060655aff3af1f0c5d20f46b57f262ab6c86a5e8", size = 240342 },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/94043e478201ffa85b8ae2d2c79b4081e5a1b73438aafafccf3e9bafb6b5/coverage-7.6.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07e2ca0ad381b91350c0ed49d52699b625aab2b44b65e1b4e02fa9df0e92ad2d", size = 237371 },
+    { url = "https://files.pythonhosted.org/packages/1f/0f/c890339dd605f3ebc269543247bdd43b703cce6825b5ed42ff5f2d6122c7/coverage-7.6.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c44fee9975f04b33331cb8eb272827111efc8930cfd582e0320613263ca849ca", size = 239455 },
+    { url = "https://files.pythonhosted.org/packages/d1/04/7fd7b39ec7372a04efb0f70c70e35857a99b6a9188b5205efb4c77d6a57a/coverage-7.6.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877abb17e6339d96bf08e7a622d05095e72b71f8afd8a9fefc82cf30ed944163", size = 238924 },
+    { url = "https://files.pythonhosted.org/packages/ed/bf/73ce346a9d32a09cf369f14d2a06651329c984e106f5992c89579d25b27e/coverage-7.6.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3e0cadcf6733c09154b461f1ca72d5416635e5e4ec4e536192180d34ec160f8a", size = 237252 },
+    { url = "https://files.pythonhosted.org/packages/86/74/1dc7a20969725e917b1e07fe71a955eb34bc606b938316bcc799f228374b/coverage-7.6.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c3c02d12f837d9683e5ab2f3d9844dc57655b92c74e286c262e0fc54213c216d", size = 238897 },
+    { url = "https://files.pythonhosted.org/packages/b6/e9/d9cc3deceb361c491b81005c668578b0dfa51eed02cd081620e9a62f24ec/coverage-7.6.1-cp312-cp312-win32.whl", hash = "sha256:e05882b70b87a18d937ca6768ff33cc3f72847cbc4de4491c8e73880766718e5", size = 209606 },
+    { url = "https://files.pythonhosted.org/packages/47/c8/5a2e41922ea6740f77d555c4d47544acd7dc3f251fe14199c09c0f5958d3/coverage-7.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:b5d7b556859dd85f3a541db6a4e0167b86e7273e1cdc973e5b175166bb634fdb", size = 210373 },
+    { url = "https://files.pythonhosted.org/packages/8c/f9/9aa4dfb751cb01c949c990d136a0f92027fbcc5781c6e921df1cb1563f20/coverage-7.6.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a4acd025ecc06185ba2b801f2de85546e0b8ac787cf9d3b06e7e2a69f925b106", size = 207007 },
+    { url = "https://files.pythonhosted.org/packages/b9/67/e1413d5a8591622a46dd04ff80873b04c849268831ed5c304c16433e7e30/coverage-7.6.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a6d3adcf24b624a7b778533480e32434a39ad8fa30c315208f6d3e5542aeb6e9", size = 207269 },
+    { url = "https://files.pythonhosted.org/packages/14/5b/9dec847b305e44a5634d0fb8498d135ab1d88330482b74065fcec0622224/coverage-7.6.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0c212c49b6c10e6951362f7c6df3329f04c2b1c28499563d4035d964ab8e08c", size = 239886 },
+    { url = "https://files.pythonhosted.org/packages/7b/b7/35760a67c168e29f454928f51f970342d23cf75a2bb0323e0f07334c85f3/coverage-7.6.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e81d7a3e58882450ec4186ca59a3f20a5d4440f25b1cff6f0902ad890e6748a", size = 237037 },
+    { url = "https://files.pythonhosted.org/packages/f7/95/d2fd31f1d638df806cae59d7daea5abf2b15b5234016a5ebb502c2f3f7ee/coverage-7.6.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78b260de9790fd81e69401c2dc8b17da47c8038176a79092a89cb2b7d945d060", size = 239038 },
+    { url = "https://files.pythonhosted.org/packages/6e/bd/110689ff5752b67924efd5e2aedf5190cbbe245fc81b8dec1abaffba619d/coverage-7.6.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a78d169acd38300060b28d600344a803628c3fd585c912cacc9ea8790fe96862", size = 238690 },
+    { url = "https://files.pythonhosted.org/packages/d3/a8/08d7b38e6ff8df52331c83130d0ab92d9c9a8b5462f9e99c9f051a4ae206/coverage-7.6.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c09f4ce52cb99dd7505cd0fc8e0e37c77b87f46bc9c1eb03fe3bc9991085388", size = 236765 },
+    { url = "https://files.pythonhosted.org/packages/d6/6a/9cf96839d3147d55ae713eb2d877f4d777e7dc5ba2bce227167d0118dfe8/coverage-7.6.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6878ef48d4227aace338d88c48738a4258213cd7b74fd9a3d4d7582bb1d8a155", size = 238611 },
+    { url = "https://files.pythonhosted.org/packages/74/e4/7ff20d6a0b59eeaab40b3140a71e38cf52547ba21dbcf1d79c5a32bba61b/coverage-7.6.1-cp313-cp313-win32.whl", hash = "sha256:44df346d5215a8c0e360307d46ffaabe0f5d3502c8a1cefd700b34baf31d411a", size = 209671 },
+    { url = "https://files.pythonhosted.org/packages/35/59/1812f08a85b57c9fdb6d0b383d779e47b6f643bc278ed682859512517e83/coverage-7.6.1-cp313-cp313-win_amd64.whl", hash = "sha256:8284cf8c0dd272a247bc154eb6c95548722dce90d098c17a883ed36e67cdb129", size = 210368 },
+    { url = "https://files.pythonhosted.org/packages/9c/15/08913be1c59d7562a3e39fce20661a98c0a3f59d5754312899acc6cb8a2d/coverage-7.6.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d3296782ca4eab572a1a4eca686d8bfb00226300dcefdf43faa25b5242ab8a3e", size = 207758 },
+    { url = "https://files.pythonhosted.org/packages/c4/ae/b5d58dff26cade02ada6ca612a76447acd69dccdbb3a478e9e088eb3d4b9/coverage-7.6.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:502753043567491d3ff6d08629270127e0c31d4184c4c8d98f92c26f65019962", size = 208035 },
+    { url = "https://files.pythonhosted.org/packages/b8/d7/62095e355ec0613b08dfb19206ce3033a0eedb6f4a67af5ed267a8800642/coverage-7.6.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a89ecca80709d4076b95f89f308544ec8f7b4727e8a547913a35f16717856cb", size = 250839 },
+    { url = "https://files.pythonhosted.org/packages/7c/1e/c2967cb7991b112ba3766df0d9c21de46b476d103e32bb401b1b2adf3380/coverage-7.6.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a318d68e92e80af8b00fa99609796fdbcdfef3629c77c6283566c6f02c6d6704", size = 246569 },
+    { url = "https://files.pythonhosted.org/packages/8b/61/a7a6a55dd266007ed3b1df7a3386a0d760d014542d72f7c2c6938483b7bd/coverage-7.6.1-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13b0a73a0896988f053e4fbb7de6d93388e6dd292b0d87ee51d106f2c11b465b", size = 248927 },
+    { url = "https://files.pythonhosted.org/packages/c8/fa/13a6f56d72b429f56ef612eb3bc5ce1b75b7ee12864b3bd12526ab794847/coverage-7.6.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4421712dbfc5562150f7554f13dde997a2e932a6b5f352edcce948a815efee6f", size = 248401 },
+    { url = "https://files.pythonhosted.org/packages/75/06/0429c652aa0fb761fc60e8c6b291338c9173c6aa0f4e40e1902345b42830/coverage-7.6.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:166811d20dfea725e2e4baa71fffd6c968a958577848d2131f39b60043400223", size = 246301 },
+    { url = "https://files.pythonhosted.org/packages/52/76/1766bb8b803a88f93c3a2d07e30ffa359467810e5cbc68e375ebe6906efb/coverage-7.6.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:225667980479a17db1048cb2bf8bfb39b8e5be8f164b8f6628b64f78a72cf9d3", size = 247598 },
+    { url = "https://files.pythonhosted.org/packages/66/8b/f54f8db2ae17188be9566e8166ac6df105c1c611e25da755738025708d54/coverage-7.6.1-cp313-cp313t-win32.whl", hash = "sha256:170d444ab405852903b7d04ea9ae9b98f98ab6d7e63e1115e82620807519797f", size = 210307 },
+    { url = "https://files.pythonhosted.org/packages/9f/b0/e0dca6da9170aefc07515cce067b97178cefafb512d00a87a1c717d2efd5/coverage-7.6.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b9f222de8cded79c49bf184bdbc06630d4c58eec9459b939b4a690c82ed05657", size = 211453 },
+    { url = "https://files.pythonhosted.org/packages/81/d0/d9e3d554e38beea5a2e22178ddb16587dbcbe9a1ef3211f55733924bf7fa/coverage-7.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6db04803b6c7291985a761004e9060b2bca08da6d04f26a7f2294b8623a0c1a0", size = 206674 },
+    { url = "https://files.pythonhosted.org/packages/38/ea/cab2dc248d9f45b2b7f9f1f596a4d75a435cb364437c61b51d2eb33ceb0e/coverage-7.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f1adfc8ac319e1a348af294106bc6a8458a0f1633cc62a1446aebc30c5fa186a", size = 207101 },
+    { url = "https://files.pythonhosted.org/packages/ca/6f/f82f9a500c7c5722368978a5390c418d2a4d083ef955309a8748ecaa8920/coverage-7.6.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a95324a9de9650a729239daea117df21f4b9868ce32e63f8b650ebe6cef5595b", size = 236554 },
+    { url = "https://files.pythonhosted.org/packages/a6/94/d3055aa33d4e7e733d8fa309d9adf147b4b06a82c1346366fc15a2b1d5fa/coverage-7.6.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b43c03669dc4618ec25270b06ecd3ee4fa94c7f9b3c14bae6571ca00ef98b0d3", size = 234440 },
+    { url = "https://files.pythonhosted.org/packages/e4/6e/885bcd787d9dd674de4a7d8ec83faf729534c63d05d51d45d4fa168f7102/coverage-7.6.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8929543a7192c13d177b770008bc4e8119f2e1f881d563fc6b6305d2d0ebe9de", size = 235889 },
+    { url = "https://files.pythonhosted.org/packages/f4/63/df50120a7744492710854860783d6819ff23e482dee15462c9a833cc428a/coverage-7.6.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:a09ece4a69cf399510c8ab25e0950d9cf2b42f7b3cb0374f95d2e2ff594478a6", size = 235142 },
+    { url = "https://files.pythonhosted.org/packages/3a/5d/9d0acfcded2b3e9ce1c7923ca52ccc00c78a74e112fc2aee661125b7843b/coverage-7.6.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9054a0754de38d9dbd01a46621636689124d666bad1936d76c0341f7d71bf569", size = 233805 },
+    { url = "https://files.pythonhosted.org/packages/c4/56/50abf070cb3cd9b1dd32f2c88f083aab561ecbffbcd783275cb51c17f11d/coverage-7.6.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0dbde0f4aa9a16fa4d754356a8f2e36296ff4d83994b2c9d8398aa32f222f989", size = 234655 },
+    { url = "https://files.pythonhosted.org/packages/25/ee/b4c246048b8485f85a2426ef4abab88e48c6e80c74e964bea5cd4cd4b115/coverage-7.6.1-cp38-cp38-win32.whl", hash = "sha256:da511e6ad4f7323ee5702e6633085fb76c2f893aaf8ce4c51a0ba4fc07580ea7", size = 209296 },
+    { url = "https://files.pythonhosted.org/packages/5c/1c/96cf86b70b69ea2b12924cdf7cabb8ad10e6130eab8d767a1099fbd2a44f/coverage-7.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:3f1156e3e8f2872197af3840d8ad307a9dd18e615dc64d9ee41696f287c57ad8", size = 210137 },
+    { url = "https://files.pythonhosted.org/packages/19/d3/d54c5aa83268779d54c86deb39c1c4566e5d45c155369ca152765f8db413/coverage-7.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:abd5fd0db5f4dc9289408aaf34908072f805ff7792632250dcb36dc591d24255", size = 206688 },
+    { url = "https://files.pythonhosted.org/packages/a5/fe/137d5dca72e4a258b1bc17bb04f2e0196898fe495843402ce826a7419fe3/coverage-7.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:547f45fa1a93154bd82050a7f3cddbc1a7a4dd2a9bf5cb7d06f4ae29fe94eaf8", size = 207120 },
+    { url = "https://files.pythonhosted.org/packages/78/5b/a0a796983f3201ff5485323b225d7c8b74ce30c11f456017e23d8e8d1945/coverage-7.6.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:645786266c8f18a931b65bfcefdbf6952dd0dea98feee39bd188607a9d307ed2", size = 235249 },
+    { url = "https://files.pythonhosted.org/packages/4e/e1/76089d6a5ef9d68f018f65411fcdaaeb0141b504587b901d74e8587606ad/coverage-7.6.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9e0b2df163b8ed01d515807af24f63de04bebcecbd6c3bfeff88385789fdf75a", size = 233237 },
+    { url = "https://files.pythonhosted.org/packages/9a/6f/eef79b779a540326fee9520e5542a8b428cc3bfa8b7c8f1022c1ee4fc66c/coverage-7.6.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:609b06f178fe8e9f89ef676532760ec0b4deea15e9969bf754b37f7c40326dbc", size = 234311 },
+    { url = "https://files.pythonhosted.org/packages/75/e1/656d65fb126c29a494ef964005702b012f3498db1a30dd562958e85a4049/coverage-7.6.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:702855feff378050ae4f741045e19a32d57d19f3e0676d589df0575008ea5004", size = 233453 },
+    { url = "https://files.pythonhosted.org/packages/68/6a/45f108f137941a4a1238c85f28fd9d048cc46b5466d6b8dda3aba1bb9d4f/coverage-7.6.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:2bdb062ea438f22d99cba0d7829c2ef0af1d768d1e4a4f528087224c90b132cb", size = 231958 },
+    { url = "https://files.pythonhosted.org/packages/9b/e7/47b809099168b8b8c72ae311efc3e88c8d8a1162b3ba4b8da3cfcdb85743/coverage-7.6.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:9c56863d44bd1c4fe2abb8a4d6f5371d197f1ac0ebdee542f07f35895fc07f36", size = 232938 },
+    { url = "https://files.pythonhosted.org/packages/52/80/052222ba7058071f905435bad0ba392cc12006380731c37afaf3fe749b88/coverage-7.6.1-cp39-cp39-win32.whl", hash = "sha256:6e2cd258d7d927d09493c8df1ce9174ad01b381d4729a9d8d4e38670ca24774c", size = 209352 },
+    { url = "https://files.pythonhosted.org/packages/b8/d8/1b92e0b3adcf384e98770a00ca095da1b5f7b483e6563ae4eb5e935d24a1/coverage-7.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:06a737c882bd26d0d6ee7269b20b12f14a8704807a01056c80bb881a4b2ce6ca", size = 210153 },
+    { url = "https://files.pythonhosted.org/packages/a5/2b/0354ed096bca64dc8e32a7cbcae28b34cb5ad0b1fe2125d6d99583313ac0/coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df", size = 198926 },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 },
+]
+
+[[package]]
+name = "dict2xml"
+version = "1.7.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/07/b3/2db1b077f9a80d30d1729a0af69b7cef8ce5b45c77a1f0f9ebb01b9edce1/dict2xml-1.7.6.tar.gz", hash = "sha256:3e4811f4ef7fca86dede6acf382268ff9bc5735a4aa0e21b465f6eb0c4e81732", size = 15210 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/ad/5a193b6461c713058e3c5b6dbec7a9f92230a968650129cc46f32d3c9de2/dict2xml-1.7.6-py3-none-any.whl", hash = "sha256:841a0c1720e4bfa121e958b805f1062fccf5af2970e7a1f81d7fa056f49e5065", size = 8038 },
+]
+
+[[package]]
+name = "eval-type-backport"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/ca/1601a9fa588867fe2ab6c19ed4c936929160d08a86597adf61bbd443fe57/eval_type_backport-0.2.0.tar.gz", hash = "sha256:68796cfbc7371ebf923f03bdf7bef415f3ec098aeced24e054b253a0e78f7b37", size = 8977 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ac/ac/aa3d8e0acbcd71140420bc752d7c9779cf3a2a3bb1d7ef30944e38b2cd39/eval_type_backport-0.2.0-py3-none-any.whl", hash = "sha256:ac2f73d30d40c5a30a80b8739a789d6bb5e49fdffa66d7912667e2015d9c9933", size = 5855 },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.55.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4e/053fe1b5c0ce346c0a9d0557492c654362bafb14f026eae0d3ee98009152/fonttools-4.55.0.tar.gz", hash = "sha256:7636acc6ab733572d5e7eec922b254ead611f1cdad17be3f0be7418e8bfaca71", size = 3490431 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/8c/57600ebff0b2119b725bc11eeea32b17b0220f3fae71b5fff082a1891270/fonttools-4.55.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:51c029d4c0608a21a3d3d169dfc3fb776fde38f00b35ca11fdab63ba10a16f61", size = 2770301 },
+    { url = "https://files.pythonhosted.org/packages/02/94/dff7e57a751918b133a303418202b4f43e3dc3c887e2a648089e0463b1a7/fonttools-4.55.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bca35b4e411362feab28e576ea10f11268b1aeed883b9f22ed05675b1e06ac69", size = 2295806 },
+    { url = "https://files.pythonhosted.org/packages/09/31/ff18d79d449510850fe4a96c0ba50ee6d0b9b815a6b5a2489d809e9a8db5/fonttools-4.55.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ce4ba6981e10f7e0ccff6348e9775ce25ffadbee70c9fd1a3737e3e9f5fa74f", size = 4577709 },
+    { url = "https://files.pythonhosted.org/packages/c4/03/8136887d1b0b7a9831c7e8e2598c0e5851e31cc2231295769350349a236b/fonttools-4.55.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31d00f9852a6051dac23294a4cf2df80ced85d1d173a61ba90a3d8f5abc63c60", size = 4633411 },
+    { url = "https://files.pythonhosted.org/packages/a7/37/86ac06a7505e57de2daaf0a1cc885b7767c74d376ef2cf82933e8ef79399/fonttools-4.55.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e198e494ca6e11f254bac37a680473a311a88cd40e58f9cc4dc4911dfb686ec6", size = 4572887 },
+    { url = "https://files.pythonhosted.org/packages/0d/85/1e429359d1842a104b638433587ff62d9dc8339a8c467787087962502a53/fonttools-4.55.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7208856f61770895e79732e1dcbe49d77bd5783adf73ae35f87fcc267df9db81", size = 4745036 },
+    { url = "https://files.pythonhosted.org/packages/81/65/763ac1fe2a3e52220f7a7fd2a5de0c784045e773aa9d299450019ac66f9e/fonttools-4.55.0-cp310-cp310-win32.whl", hash = "sha256:e7e6a352ff9e46e8ef8a3b1fe2c4478f8a553e1b5a479f2e899f9dc5f2055880", size = 2170126 },
+    { url = "https://files.pythonhosted.org/packages/3e/67/93939482715e629c4bd6fd1f3d154c1bf45b81ee383f50e44d31fa542f83/fonttools-4.55.0-cp310-cp310-win_amd64.whl", hash = "sha256:636caaeefe586d7c84b5ee0734c1a5ab2dae619dc21c5cf336f304ddb8f6001b", size = 2213882 },
+    { url = "https://files.pythonhosted.org/packages/17/50/75461e050ded02b9eaa8097df52c2a8752cf4c24db8b44b150755b76c8f1/fonttools-4.55.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fa34aa175c91477485c44ddfbb51827d470011e558dfd5c7309eb31bef19ec51", size = 2771444 },
+    { url = "https://files.pythonhosted.org/packages/de/5e/98130db3770e8d12f70aa61f2555c32284d4e9c592862469d32b7ee48626/fonttools-4.55.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:37dbb3fdc2ef7302d3199fb12468481cbebaee849e4b04bc55b77c24e3c49189", size = 2296439 },
+    { url = "https://files.pythonhosted.org/packages/17/35/36fe271296fe7624811f5261a0662155e075b43b79ffacea85a03f36593d/fonttools-4.55.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5263d8e7ef3c0ae87fbce7f3ec2f546dc898d44a337e95695af2cd5ea21a967", size = 4883141 },
+    { url = "https://files.pythonhosted.org/packages/47/2b/9bf7527260d265281dd812951aa22f3d1c331bcc91e86e7038dc6b9737cb/fonttools-4.55.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f307f6b5bf9e86891213b293e538d292cd1677e06d9faaa4bf9c086ad5f132f6", size = 4931050 },
+    { url = "https://files.pythonhosted.org/packages/0b/7b/7324d3aa8424c71b63ba2e76eb4a46d6947e23065996e755c1682e666f42/fonttools-4.55.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f0a4b52238e7b54f998d6a56b46a2c56b59c74d4f8a6747fb9d4042190f37cd3", size = 4894154 },
+    { url = "https://files.pythonhosted.org/packages/2c/53/a54926be69e43d277877106a6cbfab467cb02f9c756258c7c9932e8eb382/fonttools-4.55.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3e569711464f777a5d4ef522e781dc33f8095ab5efd7548958b36079a9f2f88c", size = 5064715 },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/9602868af9a2dfc4659637a752da8691655e81a2d6138231dcaa1efe8840/fonttools-4.55.0-cp311-cp311-win32.whl", hash = "sha256:2b3ab90ec0f7b76c983950ac601b58949f47aca14c3f21eed858b38d7ec42b05", size = 2169536 },
+    { url = "https://files.pythonhosted.org/packages/30/57/9e2ddd16ad84ab26616ae4346b3b15e9a50669ca1b442cbe760af073807c/fonttools-4.55.0-cp311-cp311-win_amd64.whl", hash = "sha256:aa046f6a63bb2ad521004b2769095d4c9480c02c1efa7d7796b37826508980b6", size = 2215265 },
+    { url = "https://files.pythonhosted.org/packages/ec/79/38209f8f6235021b6209147ec7b2f748afde65c59c6274ac96fef3912094/fonttools-4.55.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:838d2d8870f84fc785528a692e724f2379d5abd3fc9dad4d32f91cf99b41e4a7", size = 2765205 },
+    { url = "https://files.pythonhosted.org/packages/e3/07/434a21eab80524613c9753db2ff21d6bc3cf264412d8833a85022fd39088/fonttools-4.55.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f46b863d74bab7bb0d395f3b68d3f52a03444964e67ce5c43ce43a75efce9246", size = 2293908 },
+    { url = "https://files.pythonhosted.org/packages/c8/63/aa3274d9be36aaaef8c087e413cbc1dd682ff94776a82c111bad88482947/fonttools-4.55.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33b52a9cfe4e658e21b1f669f7309b4067910321757fec53802ca8f6eae96a5a", size = 4795901 },
+    { url = "https://files.pythonhosted.org/packages/fc/0b/dbe13f2c8d745ffdf5c2bc25391263927d4ec2b927e44d5d5f70cd372873/fonttools-4.55.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:732a9a63d6ea4a81b1b25a1f2e5e143761b40c2e1b79bb2b68e4893f45139a40", size = 4879252 },
+    { url = "https://files.pythonhosted.org/packages/46/85/eefb400ec66e9e7c159d13c72aba473d9c2a0c556d812b0916418aa9019e/fonttools-4.55.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7dd91ac3fcb4c491bb4763b820bcab6c41c784111c24172616f02f4bc227c17d", size = 4773177 },
+    { url = "https://files.pythonhosted.org/packages/93/75/f06d175df4d7dbad97061c8698210ce4231cce9aa56cc263f3b6b5340540/fonttools-4.55.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1f0e115281a32ff532118aa851ef497a1b7cda617f4621c1cdf81ace3e36fb0c", size = 5032809 },
+    { url = "https://files.pythonhosted.org/packages/78/eb/f3520ba63b5e4a034f2bfd34d8ab32eb95a1bf37a1f792ea48461fba08f6/fonttools-4.55.0-cp312-cp312-win32.whl", hash = "sha256:6c99b5205844f48a05cb58d4a8110a44d3038c67ed1d79eb733c4953c628b0f6", size = 2157762 },
+    { url = "https://files.pythonhosted.org/packages/aa/d1/5f007861cab890f2a35a19a1d2a2815655ec10b0ea7fd881b1d3aaab0076/fonttools-4.55.0-cp312-cp312-win_amd64.whl", hash = "sha256:f8c8c76037d05652510ae45be1cd8fb5dd2fd9afec92a25374ac82255993d57c", size = 2203746 },
+    { url = "https://files.pythonhosted.org/packages/c3/87/a669ac26c6077e37ffb06abf29c5571789eefe518d06c52df392181ee694/fonttools-4.55.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8118dc571921dc9e4b288d9cb423ceaf886d195a2e5329cc427df82bba872cd9", size = 2752519 },
+    { url = "https://files.pythonhosted.org/packages/0c/e9/4822ad238fe215133c7df20f1cdb1a58cfb634a31523e77ff0fb2033970a/fonttools-4.55.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01124f2ca6c29fad4132d930da69158d3f49b2350e4a779e1efbe0e82bd63f6c", size = 2286819 },
+    { url = "https://files.pythonhosted.org/packages/3e/a4/d7941c3897129e60fe68d20e4819fda4d0c4858d77badae0e80ca6440b36/fonttools-4.55.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81ffd58d2691f11f7c8438796e9f21c374828805d33e83ff4b76e4635633674c", size = 4770382 },
+    { url = "https://files.pythonhosted.org/packages/31/cf/c51ea1348f9fba9c627439afad9dee0090040809ab431f4422b5bfdda34c/fonttools-4.55.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5435e5f1eb893c35c2bc2b9cd3c9596b0fcb0a59e7a14121562986dd4c47b8dd", size = 4858336 },
+    { url = "https://files.pythonhosted.org/packages/73/be/36c1fe0e5c9a96b068ddd7e82001243bbe7fe12549c8d14e1bd025bf40c9/fonttools-4.55.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d12081729280c39d001edd0f4f06d696014c26e6e9a0a55488fabc37c28945e4", size = 4756072 },
+    { url = "https://files.pythonhosted.org/packages/5c/18/6dd381c29f215a017f79aa9fea0722424a0046b47991c4390a78ff87ce0c/fonttools-4.55.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a7ad1f1b98ab6cb927ab924a38a8649f1ffd7525c75fe5b594f5dab17af70e18", size = 5008668 },
+    { url = "https://files.pythonhosted.org/packages/b8/95/316f20092b389b927dba1d1dccd3f541853f96e707e210f1b9f4e7bacdd5/fonttools-4.55.0-cp313-cp313-win32.whl", hash = "sha256:abe62987c37630dca69a104266277216de1023cf570c1643bb3a19a9509e7a1b", size = 2155841 },
+    { url = "https://files.pythonhosted.org/packages/35/ca/b4638aa3e446184892e2f9cc8ef44bb506f47fea04580df7fb84f5a4363d/fonttools-4.55.0-cp313-cp313-win_amd64.whl", hash = "sha256:2863555ba90b573e4201feaf87a7e71ca3b97c05aa4d63548a4b69ea16c9e998", size = 2200587 },
+    { url = "https://files.pythonhosted.org/packages/d5/42/07f8fa04fca7280bd03d1a71a5dd6cc06f0e6de564475452b278ca33cb46/fonttools-4.55.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:00f7cf55ad58a57ba421b6a40945b85ac7cc73094fb4949c41171d3619a3a47e", size = 2768390 },
+    { url = "https://files.pythonhosted.org/packages/0b/34/e0cf074e35aa6887066059f4e718c12b664dc4abbd5ceeb57d491768dbad/fonttools-4.55.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f27526042efd6f67bfb0cc2f1610fa20364396f8b1fc5edb9f45bb815fb090b2", size = 2294539 },
+    { url = "https://files.pythonhosted.org/packages/b7/2d/e9181f4d74bc9a6e2c68681516eb36de71ded5456eea9d19eeaa5c89688f/fonttools-4.55.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8e67974326af6a8879dc2a4ec63ab2910a1c1a9680ccd63e4a690950fceddbe", size = 4661079 },
+    { url = "https://files.pythonhosted.org/packages/63/b2/132beb97872729968db86ab5f421269f1b4920c627a9c1c0abc69d50b1b8/fonttools-4.55.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61dc0a13451143c5e987dec5254d9d428f3c2789a549a7cf4f815b63b310c1cc", size = 4725915 },
+    { url = "https://files.pythonhosted.org/packages/98/c8/d56ff65526595519f9c1e614c09d65e544a4037709f7ca1181a9d104ef9a/fonttools-4.55.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:b2e526b325a903868c62155a6a7e24df53f6ce4c5c3160214d8fe1be2c41b478", size = 4678541 },
+    { url = "https://files.pythonhosted.org/packages/2b/81/00a6bf554e0440ae80268ae69c691b12d8dbded4e16c21aeedde4cde1037/fonttools-4.55.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:b7ef9068a1297714e6fefe5932c33b058aa1d45a2b8be32a4c6dee602ae22b5c", size = 4854488 },
+    { url = "https://files.pythonhosted.org/packages/d6/85/5688777edbcb5d500db8fbc9c5e4ad9963d82b1a5dd63669016fc205ba78/fonttools-4.55.0-cp38-cp38-win32.whl", hash = "sha256:55718e8071be35dff098976bc249fc243b58efa263768c611be17fe55975d40a", size = 1493406 },
+    { url = "https://files.pythonhosted.org/packages/85/40/54622b2e6788ff6c7781759f3da059ccd7e5a70fde5436974626bb91b5a2/fonttools-4.55.0-cp38-cp38-win_amd64.whl", hash = "sha256:553bd4f8cc327f310c20158e345e8174c8eed49937fb047a8bda51daf2c353c8", size = 1537702 },
+    { url = "https://files.pythonhosted.org/packages/ca/83/12c26ce25df9de2d247c31f27cddd1acd08078ad18631032db6ce946f01e/fonttools-4.55.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f901cef813f7c318b77d1c5c14cf7403bae5cb977cede023e22ba4316f0a8f6", size = 2773168 },
+    { url = "https://files.pythonhosted.org/packages/db/19/03e7de9889c668e19c34bfb6c261252294b6ddeb06cd5f9864bf01f162a1/fonttools-4.55.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8c9679fc0dd7e8a5351d321d8d29a498255e69387590a86b596a45659a39eb0d", size = 2297131 },
+    { url = "https://files.pythonhosted.org/packages/e3/9d/5f981c69f99d07e59a7f2f58efa91e87ffc3bbd548a2979704a3382f53df/fonttools-4.55.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd2820a8b632f3307ebb0bf57948511c2208e34a4939cf978333bc0a3f11f838", size = 4582322 },
+    { url = "https://files.pythonhosted.org/packages/1d/3e/0841e7bf38ad317c960992dd03bac041899a1c21396013e6ddcfd2bc48c5/fonttools-4.55.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23bbbb49bec613a32ed1b43df0f2b172313cee690c2509f1af8fdedcf0a17438", size = 4640834 },
+    { url = "https://files.pythonhosted.org/packages/3a/0f/39e95369fae73e06b5110fdc245f71c82f2d6870a2cef96440045a2a3b23/fonttools-4.55.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:a656652e1f5d55b9728937a7e7d509b73d23109cddd4e89ee4f49bde03b736c6", size = 4575466 },
+    { url = "https://files.pythonhosted.org/packages/5e/e6/fed351dec03c335eeaf3d276c1b3995c33c59bde0ed7911bc8d55661a41b/fonttools-4.55.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f50a1f455902208486fbca47ce33054208a4e437b38da49d6721ce2fef732fcf", size = 4748309 },
+    { url = "https://files.pythonhosted.org/packages/c2/8c/6295c8b395f26b7c6be42ac55308b704b4c0709a2e7770c54d64810150c1/fonttools-4.55.0-cp39-cp39-win32.whl", hash = "sha256:161d1ac54c73d82a3cded44202d0218ab007fde8cf194a23d3dd83f7177a2f03", size = 2170761 },
+    { url = "https://files.pythonhosted.org/packages/9b/fa/0bd359e011f71afb11f33d8f7adc9cd81213a42c8e62d05ba75befd228ad/fonttools-4.55.0-cp39-cp39-win_amd64.whl", hash = "sha256:ca7fd6987c68414fece41c96836e945e1f320cda56fc96ffdc16e54a44ec57a2", size = 2214479 },
+    { url = "https://files.pythonhosted.org/packages/b4/4a/786589606d4989cb34d8bc766cd687d955aaf3039c367fe7104bcf82dc98/fonttools-4.55.0-py3-none-any.whl", hash = "sha256:12db5888cd4dd3fcc9f0ee60c6edd3c7e1fd44b7dd0f31381ea03df68f8a153f", size = 1100249 },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
+]
+
+[[package]]
+name = "imageio"
+version = "2.35.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "pillow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/82/bf/d0ddda79819405428f40e4bc9245c2b936a3a2b23d83b6e42d83822ef822/imageio-2.35.1.tar.gz", hash = "sha256:4952dfeef3c3947957f6d5dedb1f4ca31c6e509a476891062396834048aeed2a", size = 389686 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/b7/02adac4e42a691008b5cfb31db98c190e1fc348d1521b9be4429f9454ed1/imageio-2.35.1-py3-none-any.whl", hash = "sha256:6eb2e5244e7a16b85c10b5c2fe0f7bf961b40fcb9f1a9fd1bd1d2c2f8fb3cd65", size = 315378 },
+]
+
+[[package]]
+name = "importlib-resources"
+version = "6.4.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp", marker = "python_full_version < '3.10'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/be/f3e8c6081b684f176b761e6a2fef02a0be939740ed6f54109a2951d806f3/importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065", size = 43372 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/6a/4604f9ae2fa62ef47b9de2fa5ad599589d28c9fd1d335f32759813dfa91e/importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717", size = 36115 },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 },
+]
+
+[[package]]
+name = "interrogate"
+version = "1.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "click" },
+    { name = "colorama" },
+    { name = "py" },
+    { name = "tabulate" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8b/22/74f7fcc96280eea46cf2bcbfa1354ac31de0e60a4be6f7966f12cef20893/interrogate-1.7.0.tar.gz", hash = "sha256:a320d6ec644dfd887cc58247a345054fc4d9f981100c45184470068f4b3719b0", size = 159636 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/c9/6869a1dcf4aaf309b9543ec070be3ec3adebee7c9bec9af8c230494134b9/interrogate-1.7.0-py3-none-any.whl", hash = "sha256:b13ff4dd8403369670e2efe684066de9fcb868ad9d7f2b4095d8112142dc9d12", size = 46982 },
+]
+
+[[package]]
+name = "jmespath"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256 },
+]
+
+[[package]]
+name = "joblib"
+version = "1.4.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/33/60135848598c076ce4b231e1b1895170f45fbcaeaa2c9d5e38b04db70c35/joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e", size = 2116621 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/29/df4b9b42f2be0b623cbd5e2140cafcaa2bef0759a00b7b70104dcfe2fb51/joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6", size = 301817 },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/4d/2255e1c76304cbd60b48cee302b66d1dde4468dc5b1160e4b7cb43778f2a/kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60", size = 97286 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/97/14/fc943dd65268a96347472b4fbe5dcc2f6f55034516f80576cd0dd3a8930f/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6", size = 122440 },
+    { url = "https://files.pythonhosted.org/packages/1e/46/e68fed66236b69dd02fcdb506218c05ac0e39745d696d22709498896875d/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17", size = 65758 },
+    { url = "https://files.pythonhosted.org/packages/ef/fa/65de49c85838681fc9cb05de2a68067a683717321e01ddafb5b8024286f0/kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9", size = 64311 },
+    { url = "https://files.pythonhosted.org/packages/42/9c/cc8d90f6ef550f65443bad5872ffa68f3dee36de4974768628bea7c14979/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8d53103597a252fb3ab8b5845af04c7a26d5e7ea8122303dd7a021176a87e8b9", size = 1637109 },
+    { url = "https://files.pythonhosted.org/packages/55/91/0a57ce324caf2ff5403edab71c508dd8f648094b18cfbb4c8cc0fde4a6ac/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c", size = 1617814 },
+    { url = "https://files.pythonhosted.org/packages/12/5d/c36140313f2510e20207708adf36ae4919416d697ee0236b0ddfb6fd1050/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a9ca9c710d598fd75ee5de59d5bda2684d9db36a9f50b6125eaea3969c2599", size = 1400881 },
+    { url = "https://files.pythonhosted.org/packages/56/d0/786e524f9ed648324a466ca8df86298780ef2b29c25313d9a4f16992d3cf/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4d742cb7af1c28303a51b7a27aaee540e71bb8e24f68c736f6f2ffc82f2bf05", size = 1512972 },
+    { url = "https://files.pythonhosted.org/packages/67/5a/77851f2f201e6141d63c10a0708e996a1363efaf9e1609ad0441b343763b/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e28c7fea2196bf4c2f8d46a0415c77a1c480cc0724722f23d7410ffe9842c407", size = 1444787 },
+    { url = "https://files.pythonhosted.org/packages/06/5f/1f5eaab84355885e224a6fc8d73089e8713dc7e91c121f00b9a1c58a2195/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e968b84db54f9d42046cf154e02911e39c0435c9801681e3fc9ce8a3c4130278", size = 2199212 },
+    { url = "https://files.pythonhosted.org/packages/b5/28/9152a3bfe976a0ae21d445415defc9d1cd8614b2910b7614b30b27a47270/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0c18ec74c0472de033e1bebb2911c3c310eef5649133dd0bedf2a169a1b269e5", size = 2346399 },
+    { url = "https://files.pythonhosted.org/packages/26/f6/453d1904c52ac3b400f4d5e240ac5fec25263716723e44be65f4d7149d13/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8f0ea6da6d393d8b2e187e6a5e3fb81f5862010a40c3945e2c6d12ae45cfb2ad", size = 2308688 },
+    { url = "https://files.pythonhosted.org/packages/5a/9a/d4968499441b9ae187e81745e3277a8b4d7c60840a52dc9d535a7909fac3/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:f106407dda69ae456dd1227966bf445b157ccc80ba0dff3802bb63f30b74e895", size = 2445493 },
+    { url = "https://files.pythonhosted.org/packages/07/c9/032267192e7828520dacb64dfdb1d74f292765f179e467c1cba97687f17d/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84ec80df401cfee1457063732d90022f93951944b5b58975d34ab56bb150dfb3", size = 2262191 },
+    { url = "https://files.pythonhosted.org/packages/6c/ad/db0aedb638a58b2951da46ddaeecf204be8b4f5454df020d850c7fa8dca8/kiwisolver-1.4.7-cp310-cp310-win32.whl", hash = "sha256:71bb308552200fb2c195e35ef05de12f0c878c07fc91c270eb3d6e41698c3bcc", size = 46644 },
+    { url = "https://files.pythonhosted.org/packages/12/ca/d0f7b7ffbb0be1e7c2258b53554efec1fd652921f10d7d85045aff93ab61/kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c", size = 55877 },
+    { url = "https://files.pythonhosted.org/packages/97/6c/cfcc128672f47a3e3c0d918ecb67830600078b025bfc32d858f2e2d5c6a4/kiwisolver-1.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:78a42513018c41c2ffd262eb676442315cbfe3c44eed82385c2ed043bc63210a", size = 48347 },
+    { url = "https://files.pythonhosted.org/packages/e9/44/77429fa0a58f941d6e1c58da9efe08597d2e86bf2b2cce6626834f49d07b/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54", size = 122442 },
+    { url = "https://files.pythonhosted.org/packages/e5/20/8c75caed8f2462d63c7fd65e16c832b8f76cda331ac9e615e914ee80bac9/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a8781ac3edc42ea4b90bc23e7d37b665d89423818e26eb6df90698aa2287c95", size = 65762 },
+    { url = "https://files.pythonhosted.org/packages/f4/98/fe010f15dc7230f45bc4cf367b012d651367fd203caaa992fd1f5963560e/kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935", size = 64319 },
+    { url = "https://files.pythonhosted.org/packages/8b/1b/b5d618f4e58c0675654c1e5051bcf42c776703edb21c02b8c74135541f60/kiwisolver-1.4.7-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef97b8df011141c9b0f6caf23b29379f87dd13183c978a30a3c546d2c47314cb", size = 1334260 },
+    { url = "https://files.pythonhosted.org/packages/b8/01/946852b13057a162a8c32c4c8d2e9ed79f0bb5d86569a40c0b5fb103e373/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab58c12a2cd0fc769089e6d38466c46d7f76aced0a1f54c77652446733d2d02", size = 1426589 },
+    { url = "https://files.pythonhosted.org/packages/70/d1/c9f96df26b459e15cf8a965304e6e6f4eb291e0f7a9460b4ad97b047561e/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:803b8e1459341c1bb56d1c5c010406d5edec8a0713a0945851290a7930679b51", size = 1541080 },
+    { url = "https://files.pythonhosted.org/packages/d3/73/2686990eb8b02d05f3de759d6a23a4ee7d491e659007dd4c075fede4b5d0/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9a9e8a507420fe35992ee9ecb302dab68550dedc0da9e2880dd88071c5fb052", size = 1470049 },
+    { url = "https://files.pythonhosted.org/packages/a7/4b/2db7af3ed3af7c35f388d5f53c28e155cd402a55432d800c543dc6deb731/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18", size = 1426376 },
+    { url = "https://files.pythonhosted.org/packages/05/83/2857317d04ea46dc5d115f0df7e676997bbd968ced8e2bd6f7f19cfc8d7f/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6af936f79086a89b3680a280c47ea90b4df7047b5bdf3aa5c524bbedddb9e545", size = 2222231 },
+    { url = "https://files.pythonhosted.org/packages/0d/b5/866f86f5897cd4ab6d25d22e403404766a123f138bd6a02ecb2cdde52c18/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3abc5b19d24af4b77d1598a585b8a719beb8569a71568b66f4ebe1fb0449460b", size = 2368634 },
+    { url = "https://files.pythonhosted.org/packages/c1/ee/73de8385403faba55f782a41260210528fe3273d0cddcf6d51648202d6d0/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:933d4de052939d90afbe6e9d5273ae05fb836cc86c15b686edd4b3560cc0ee36", size = 2329024 },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/cd101d8cd2cdfaa42dc06c433df17c8303d31129c9fdd16c0ea37672af91/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:65e720d2ab2b53f1f72fb5da5fb477455905ce2c88aaa671ff0a447c2c80e8e3", size = 2468484 },
+    { url = "https://files.pythonhosted.org/packages/e1/72/84f09d45a10bc57a40bb58b81b99d8f22b58b2040c912b7eb97ebf625bf2/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3bf1ed55088f214ba6427484c59553123fdd9b218a42bbc8c6496d6754b1e523", size = 2284078 },
+    { url = "https://files.pythonhosted.org/packages/d2/d4/71828f32b956612dc36efd7be1788980cb1e66bfb3706e6dec9acad9b4f9/kiwisolver-1.4.7-cp311-cp311-win32.whl", hash = "sha256:4c00336b9dd5ad96d0a558fd18a8b6f711b7449acce4c157e7343ba92dd0cf3d", size = 46645 },
+    { url = "https://files.pythonhosted.org/packages/a1/65/d43e9a20aabcf2e798ad1aff6c143ae3a42cf506754bcb6a7ed8259c8425/kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b", size = 56022 },
+    { url = "https://files.pythonhosted.org/packages/35/b3/9f75a2e06f1b4ca00b2b192bc2b739334127d27f1d0625627ff8479302ba/kiwisolver-1.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:e33e8fbd440c917106b237ef1a2f1449dfbb9b6f6e1ce17c94cd6a1e0d438376", size = 48536 },
+    { url = "https://files.pythonhosted.org/packages/97/9c/0a11c714cf8b6ef91001c8212c4ef207f772dd84540104952c45c1f0a249/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2", size = 121808 },
+    { url = "https://files.pythonhosted.org/packages/f2/d8/0fe8c5f5d35878ddd135f44f2af0e4e1d379e1c7b0716f97cdcb88d4fd27/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a", size = 65531 },
+    { url = "https://files.pythonhosted.org/packages/80/c5/57fa58276dfdfa612241d640a64ca2f76adc6ffcebdbd135b4ef60095098/kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee", size = 63894 },
+    { url = "https://files.pythonhosted.org/packages/8b/e9/26d3edd4c4ad1c5b891d8747a4f81b1b0aba9fb9721de6600a4adc09773b/kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640", size = 1369296 },
+    { url = "https://files.pythonhosted.org/packages/b6/67/3f4850b5e6cffb75ec40577ddf54f7b82b15269cc5097ff2e968ee32ea7d/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f", size = 1461450 },
+    { url = "https://files.pythonhosted.org/packages/52/be/86cbb9c9a315e98a8dc6b1d23c43cffd91d97d49318854f9c37b0e41cd68/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483", size = 1579168 },
+    { url = "https://files.pythonhosted.org/packages/0f/00/65061acf64bd5fd34c1f4ae53f20b43b0a017a541f242a60b135b9d1e301/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258", size = 1507308 },
+    { url = "https://files.pythonhosted.org/packages/21/e4/c0b6746fd2eb62fe702118b3ca0cb384ce95e1261cfada58ff693aeec08a/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e", size = 1464186 },
+    { url = "https://files.pythonhosted.org/packages/0a/0f/529d0a9fffb4d514f2782c829b0b4b371f7f441d61aa55f1de1c614c4ef3/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107", size = 2247877 },
+    { url = "https://files.pythonhosted.org/packages/d1/e1/66603ad779258843036d45adcbe1af0d1a889a07af4635f8b4ec7dccda35/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948", size = 2404204 },
+    { url = "https://files.pythonhosted.org/packages/8d/61/de5fb1ca7ad1f9ab7970e340a5b833d735df24689047de6ae71ab9d8d0e7/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038", size = 2352461 },
+    { url = "https://files.pythonhosted.org/packages/ba/d2/0edc00a852e369827f7e05fd008275f550353f1f9bcd55db9363d779fc63/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383", size = 2501358 },
+    { url = "https://files.pythonhosted.org/packages/84/15/adc15a483506aec6986c01fb7f237c3aec4d9ed4ac10b756e98a76835933/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520", size = 2314119 },
+    { url = "https://files.pythonhosted.org/packages/36/08/3a5bb2c53c89660863a5aa1ee236912269f2af8762af04a2e11df851d7b2/kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b", size = 46367 },
+    { url = "https://files.pythonhosted.org/packages/19/93/c05f0a6d825c643779fc3c70876bff1ac221f0e31e6f701f0e9578690d70/kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb", size = 55884 },
+    { url = "https://files.pythonhosted.org/packages/d2/f9/3828d8f21b6de4279f0667fb50a9f5215e6fe57d5ec0d61905914f5b6099/kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a", size = 48528 },
+    { url = "https://files.pythonhosted.org/packages/c4/06/7da99b04259b0f18b557a4effd1b9c901a747f7fdd84cf834ccf520cb0b2/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e", size = 121913 },
+    { url = "https://files.pythonhosted.org/packages/97/f5/b8a370d1aa593c17882af0a6f6755aaecd643640c0ed72dcfd2eafc388b9/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6", size = 65627 },
+    { url = "https://files.pythonhosted.org/packages/2a/fc/6c0374f7503522539e2d4d1b497f5ebad3f8ed07ab51aed2af988dd0fb65/kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750", size = 63888 },
+    { url = "https://files.pythonhosted.org/packages/bf/3e/0b7172793d0f41cae5c923492da89a2ffcd1adf764c16159ca047463ebd3/kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d", size = 1369145 },
+    { url = "https://files.pythonhosted.org/packages/77/92/47d050d6f6aced2d634258123f2688fbfef8ded3c5baf2c79d94d91f1f58/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379", size = 1461448 },
+    { url = "https://files.pythonhosted.org/packages/9c/1b/8f80b18e20b3b294546a1adb41701e79ae21915f4175f311a90d042301cf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c", size = 1578750 },
+    { url = "https://files.pythonhosted.org/packages/a4/fe/fe8e72f3be0a844f257cadd72689c0848c6d5c51bc1d60429e2d14ad776e/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34", size = 1507175 },
+    { url = "https://files.pythonhosted.org/packages/39/fa/cdc0b6105d90eadc3bee525fecc9179e2b41e1ce0293caaf49cb631a6aaf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1", size = 1463963 },
+    { url = "https://files.pythonhosted.org/packages/6e/5c/0c03c4e542720c6177d4f408e56d1c8315899db72d46261a4e15b8b33a41/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f", size = 2248220 },
+    { url = "https://files.pythonhosted.org/packages/3d/ee/55ef86d5a574f4e767df7da3a3a7ff4954c996e12d4fbe9c408170cd7dcc/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b", size = 2404463 },
+    { url = "https://files.pythonhosted.org/packages/0f/6d/73ad36170b4bff4825dc588acf4f3e6319cb97cd1fb3eb04d9faa6b6f212/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27", size = 2352842 },
+    { url = "https://files.pythonhosted.org/packages/0b/16/fa531ff9199d3b6473bb4d0f47416cdb08d556c03b8bc1cccf04e756b56d/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a", size = 2501635 },
+    { url = "https://files.pythonhosted.org/packages/78/7e/aa9422e78419db0cbe75fb86d8e72b433818f2e62e2e394992d23d23a583/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee", size = 2314556 },
+    { url = "https://files.pythonhosted.org/packages/a8/b2/15f7f556df0a6e5b3772a1e076a9d9f6c538ce5f05bd590eca8106508e06/kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07", size = 46364 },
+    { url = "https://files.pythonhosted.org/packages/0b/db/32e897e43a330eee8e4770bfd2737a9584b23e33587a0812b8e20aac38f7/kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76", size = 55887 },
+    { url = "https://files.pythonhosted.org/packages/c8/a4/df2bdca5270ca85fd25253049eb6708d4127be2ed0e5c2650217450b59e9/kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650", size = 48530 },
+    { url = "https://files.pythonhosted.org/packages/57/d6/620247574d9e26fe24384087879e8399e309f0051782f95238090afa6ccc/kiwisolver-1.4.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5d5abf8f8ec1f4e22882273c423e16cae834c36856cac348cfbfa68e01c40f3a", size = 122325 },
+    { url = "https://files.pythonhosted.org/packages/bd/c6/572ad7d73dbd898cffa9050ffd7ff7e78a055a1d9b7accd6b4d1f50ec858/kiwisolver-1.4.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:aeb3531b196ef6f11776c21674dba836aeea9d5bd1cf630f869e3d90b16cfade", size = 65679 },
+    { url = "https://files.pythonhosted.org/packages/14/a7/bb8ab10e12cc8764f4da0245d72dee4731cc720bdec0f085d5e9c6005b98/kiwisolver-1.4.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7d755065e4e866a8086c9bdada157133ff466476a2ad7861828e17b6026e22c", size = 64267 },
+    { url = "https://files.pythonhosted.org/packages/54/a4/3b5a2542429e182a4df0528214e76803f79d016110f5e67c414a0357cd7d/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08471d4d86cbaec61f86b217dd938a83d85e03785f51121e791a6e6689a3be95", size = 1387236 },
+    { url = "https://files.pythonhosted.org/packages/a6/d7/bc3005e906c1673953a3e31ee4f828157d5e07a62778d835dd937d624ea0/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bbfcb7165ce3d54a3dfbe731e470f65739c4c1f85bb1018ee912bae139e263b", size = 1500555 },
+    { url = "https://files.pythonhosted.org/packages/09/a7/87cb30741f13b7af08446795dca6003491755805edc9c321fe996c1320b8/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d34eb8494bea691a1a450141ebb5385e4b69d38bb8403b5146ad279f4b30fa3", size = 1431684 },
+    { url = "https://files.pythonhosted.org/packages/37/a4/1e4e2d8cdaa42c73d523413498445247e615334e39401ae49dae74885429/kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9242795d174daa40105c1d86aba618e8eab7bf96ba8c3ee614da8302a9f95503", size = 1125811 },
+    { url = "https://files.pythonhosted.org/packages/76/36/ae40d7a3171e06f55ac77fe5536079e7be1d8be2a8210e08975c7f9b4d54/kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0f64a48bb81af7450e641e3fe0b0394d7381e342805479178b3d335d60ca7cf", size = 1179987 },
+    { url = "https://files.pythonhosted.org/packages/d8/5d/6e4894b9fdf836d8bd095729dff123bbbe6ad0346289287b45c800fae656/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:8e045731a5416357638d1700927529e2b8ab304811671f665b225f8bf8d8f933", size = 2186817 },
+    { url = "https://files.pythonhosted.org/packages/f0/2d/603079b2c2fd62890be0b0ebfc8bb6dda8a5253ca0758885596565b0dfc1/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4322872d5772cae7369f8351da1edf255a604ea7087fe295411397d0cfd9655e", size = 2332538 },
+    { url = "https://files.pythonhosted.org/packages/bb/2a/9a28279c865c38a27960db38b07179143aafc94877945c209bfc553d9dd3/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:e1631290ee9271dffe3062d2634c3ecac02c83890ada077d225e081aca8aab89", size = 2293890 },
+    { url = "https://files.pythonhosted.org/packages/1a/4d/4da8967f3bf13c764984b8fbae330683ee5fbd555b4a5624ad2b9decc0ab/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:edcfc407e4eb17e037bca59be0e85a2031a2ac87e4fed26d3e9df88b4165f92d", size = 2434677 },
+    { url = "https://files.pythonhosted.org/packages/08/e9/a97a2b6b74dd850fa5974309367e025c06093a143befe9b962d0baebb4f0/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:4d05d81ecb47d11e7f8932bd8b61b720bf0b41199358f3f5e36d38e28f0532c5", size = 2250339 },
+    { url = "https://files.pythonhosted.org/packages/8a/e7/55507a387ba1766e69f5e13a79e1aefabdafe0532bee5d1972dfc42b3d16/kiwisolver-1.4.7-cp38-cp38-win32.whl", hash = "sha256:b38ac83d5f04b15e515fd86f312479d950d05ce2368d5413d46c088dda7de90a", size = 46932 },
+    { url = "https://files.pythonhosted.org/packages/52/77/7e04cca2ff1dc6ee6b7654cebe233de72b7a3ec5616501b6f3144fb70740/kiwisolver-1.4.7-cp38-cp38-win_amd64.whl", hash = "sha256:d83db7cde68459fc803052a55ace60bea2bae361fc3b7a6d5da07e11954e4b09", size = 55836 },
+    { url = "https://files.pythonhosted.org/packages/11/88/37ea0ea64512997b13d69772db8dcdc3bfca5442cda3a5e4bb943652ee3e/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd", size = 122449 },
+    { url = "https://files.pythonhosted.org/packages/4e/45/5a5c46078362cb3882dcacad687c503089263c017ca1241e0483857791eb/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e8df2eb9b2bac43ef8b082e06f750350fbbaf2887534a5be97f6cf07b19d9583", size = 65757 },
+    { url = "https://files.pythonhosted.org/packages/8a/be/a6ae58978772f685d48dd2e84460937761c53c4bbd84e42b0336473d9775/kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417", size = 64312 },
+    { url = "https://files.pythonhosted.org/packages/f4/04/18ef6f452d311e1e1eb180c9bf5589187fa1f042db877e6fe443ef10099c/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e2e6c39bd7b9372b0be21456caab138e8e69cc0fc1190a9dfa92bd45a1e6e904", size = 1626966 },
+    { url = "https://files.pythonhosted.org/packages/21/b1/40655f6c3fa11ce740e8a964fa8e4c0479c87d6a7944b95af799c7a55dfe/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a", size = 1607044 },
+    { url = "https://files.pythonhosted.org/packages/fd/93/af67dbcfb9b3323bbd2c2db1385a7139d8f77630e4a37bb945b57188eb2d/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79849239c39b5e1fd906556c474d9b0439ea6792b637511f3fe3a41158d89ca8", size = 1391879 },
+    { url = "https://files.pythonhosted.org/packages/40/6f/d60770ef98e77b365d96061d090c0cd9e23418121c55fff188fa4bdf0b54/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5e3bc157fed2a4c02ec468de4ecd12a6e22818d4f09cde2c31ee3226ffbefab2", size = 1504751 },
+    { url = "https://files.pythonhosted.org/packages/fa/3a/5f38667d313e983c432f3fcd86932177519ed8790c724e07d77d1de0188a/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3da53da805b71e41053dc670f9a820d1157aae77b6b944e08024d17bcd51ef88", size = 1436990 },
+    { url = "https://files.pythonhosted.org/packages/cb/3b/1520301a47326e6a6043b502647e42892be33b3f051e9791cc8bb43f1a32/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8705f17dfeb43139a692298cb6637ee2e59c0194538153e83e9ee0c75c2eddde", size = 2191122 },
+    { url = "https://files.pythonhosted.org/packages/cf/c4/eb52da300c166239a2233f1f9c4a1b767dfab98fae27681bfb7ea4873cb6/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:82a5c2f4b87c26bb1a0ef3d16b5c4753434633b83d365cc0ddf2770c93829e3c", size = 2338126 },
+    { url = "https://files.pythonhosted.org/packages/1a/cb/42b92fd5eadd708dd9107c089e817945500685f3437ce1fd387efebc6d6e/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce8be0466f4c0d585cdb6c1e2ed07232221df101a4c6f28821d2aa754ca2d9e2", size = 2298313 },
+    { url = "https://files.pythonhosted.org/packages/4f/eb/be25aa791fe5fc75a8b1e0c965e00f942496bc04635c9aae8035f6b76dcd/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:409afdfe1e2e90e6ee7fc896f3df9a7fec8e793e58bfa0d052c8a82f99c37abb", size = 2437784 },
+    { url = "https://files.pythonhosted.org/packages/c5/22/30a66be7f3368d76ff95689e1c2e28d382383952964ab15330a15d8bfd03/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5b9c3f4ee0b9a439d2415012bd1b1cc2df59e4d6a9939f4d669241d30b414327", size = 2253988 },
+    { url = "https://files.pythonhosted.org/packages/35/d3/5f2ecb94b5211c8a04f218a76133cc8d6d153b0f9cd0b45fad79907f0689/kiwisolver-1.4.7-cp39-cp39-win32.whl", hash = "sha256:a79ae34384df2b615eefca647a2873842ac3b596418032bef9a7283675962644", size = 46980 },
+    { url = "https://files.pythonhosted.org/packages/ef/17/cd10d020578764ea91740204edc6b3236ed8106228a46f568d716b11feb2/kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4", size = 55847 },
+    { url = "https://files.pythonhosted.org/packages/91/84/32232502020bd78d1d12be7afde15811c64a95ed1f606c10456db4e4c3ac/kiwisolver-1.4.7-cp39-cp39-win_arm64.whl", hash = "sha256:764202cc7e70f767dab49e8df52c7455e8de0df5d858fa801a11aa0d882ccf3f", size = 48494 },
+    { url = "https://files.pythonhosted.org/packages/ac/59/741b79775d67ab67ced9bb38552da688c0305c16e7ee24bba7a2be253fb7/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94252291e3fe68001b1dd747b4c0b3be12582839b95ad4d1b641924d68fd4643", size = 59491 },
+    { url = "https://files.pythonhosted.org/packages/58/cc/fb239294c29a5656e99e3527f7369b174dd9cc7c3ef2dea7cb3c54a8737b/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706", size = 57648 },
+    { url = "https://files.pythonhosted.org/packages/3b/ef/2f009ac1f7aab9f81efb2d837301d255279d618d27b6015780115ac64bdd/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd3de6481f4ed8b734da5df134cd5a6a64fe32124fe83dde1e5b5f29fe30b1e6", size = 84257 },
+    { url = "https://files.pythonhosted.org/packages/81/e1/c64f50987f85b68b1c52b464bb5bf73e71570c0f7782d626d1eb283ad620/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91b5f9f1205845d488c928e8570dcb62b893372f63b8b6e98b863ebd2368ff2", size = 80906 },
+    { url = "https://files.pythonhosted.org/packages/fd/71/1687c5c0a0be2cee39a5c9c389e546f9c6e215e46b691d00d9f646892083/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4", size = 79951 },
+    { url = "https://files.pythonhosted.org/packages/ea/8b/d7497df4a1cae9367adf21665dd1f896c2a7aeb8769ad77b662c5e2bcce7/kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a", size = 55715 },
+    { url = "https://files.pythonhosted.org/packages/64/f3/2403d90821fffe496df16f6996cb328b90b0d80c06d2938a930a7732b4f1/kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bfa1acfa0c54932d5607e19a2c24646fb4c1ae2694437789129cf099789a3b00", size = 59662 },
+    { url = "https://files.pythonhosted.org/packages/fa/7d/8f409736a4a6ac04354fa530ebf46682ddb1539b0bae15f4731ff2c575bc/kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:eee3ea935c3d227d49b4eb85660ff631556841f6e567f0f7bda972df6c2c9935", size = 57753 },
+    { url = "https://files.pythonhosted.org/packages/4c/a5/3937c9abe8eedb1356071739ad437a0b486cbad27d54f4ec4733d24882ac/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f3160309af4396e0ed04db259c3ccbfdc3621b5559b5453075e5de555e1f3a1b", size = 103564 },
+    { url = "https://files.pythonhosted.org/packages/b2/18/a5ae23888f010b90d5eb8d196fed30e268056b2ded54d25b38a193bb70e9/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a17f6a29cf8935e587cc8a4dbfc8368c55edc645283db0ce9801016f83526c2d", size = 95264 },
+    { url = "https://files.pythonhosted.org/packages/f9/d0/c4240ae86306d4395e9701f1d7e6ddcc6d60c28cb0127139176cfcfc9ebe/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:10849fb2c1ecbfae45a693c070e0320a91b35dd4bcf58172c023b994283a124d", size = 78197 },
+    { url = "https://files.pythonhosted.org/packages/62/db/62423f0ab66813376a35c1e7da488ebdb4e808fcb54b7cec33959717bda1/kiwisolver-1.4.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ac542bf38a8a4be2dc6b15248d36315ccc65f0743f7b1a76688ffb6b5129a5c2", size = 56080 },
+    { url = "https://files.pythonhosted.org/packages/d5/df/ce37d9b26f07ab90880923c94d12a6ff4d27447096b4c849bfc4339ccfdf/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b01aac285f91ca889c800042c35ad3b239e704b150cfd3382adfc9dcc780e39", size = 58666 },
+    { url = "https://files.pythonhosted.org/packages/b0/d3/e4b04f43bc629ac8e186b77b2b1a251cdfa5b7610fa189dc0db622672ce6/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e", size = 57088 },
+    { url = "https://files.pythonhosted.org/packages/30/1c/752df58e2d339e670a535514d2db4fe8c842ce459776b8080fbe08ebb98e/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f37cfe618a117e50d8c240555331160d73d0411422b59b5ee217843d7b693608", size = 84321 },
+    { url = "https://files.pythonhosted.org/packages/f0/f8/fe6484e847bc6e238ec9f9828089fb2c0bb53f2f5f3a79351fde5b565e4f/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:599b5c873c63a1f6ed7eead644a8a380cfbdf5db91dcb6f85707aaab213b1674", size = 80776 },
+    { url = "https://files.pythonhosted.org/packages/9b/57/d7163c0379f250ef763aba85330a19feefb5ce6cb541ade853aaba881524/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225", size = 79984 },
+    { url = "https://files.pythonhosted.org/packages/8c/95/4a103776c265d13b3d2cd24fb0494d4e04ea435a8ef97e1b2c026d43250b/kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0", size = 55811 },
+]
+
+[[package]]
+name = "lazy-loader"
+version = "0.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6b/c875b30a1ba490860c93da4cabf479e03f584eba06fe5963f6f6644653d8/lazy_loader-0.4.tar.gz", hash = "sha256:47c75182589b91a4e1a85a136c074285a5ad4d9f39c63e0d7fb76391c4574cd1", size = 15431 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/60/d497a310bde3f01cb805196ac61b7ad6dc5dcf8dce66634dc34364b20b4f/lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc", size = 12097 },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.7.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "importlib-resources", marker = "python_full_version < '3.10'" },
+    { name = "kiwisolver" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b6/f0/3836719cc3982fbba3b840d18a59db1d0ee9ac7986f24e8c0a092851b67b/matplotlib-3.7.5.tar.gz", hash = "sha256:1e5c971558ebc811aa07f54c7b7c677d78aa518ef4c390e14673a09e0860184a", size = 38098611 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/b0/3808e86c41e5d97822d77e89d7f3cb0890725845c050d87ec53732a8b150/matplotlib-3.7.5-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:4a87b69cb1cb20943010f63feb0b2901c17a3b435f75349fd9865713bfa63925", size = 8322924 },
+    { url = "https://files.pythonhosted.org/packages/5b/05/726623be56391ba1740331ad9f1cd30e1adec61c179ddac134957a6dc2e7/matplotlib-3.7.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:d3ce45010fefb028359accebb852ca0c21bd77ec0f281952831d235228f15810", size = 7438436 },
+    { url = "https://files.pythonhosted.org/packages/15/83/89cdef49ef1e320060ec951ba33c132df211561d866c3ed144c81fd110b2/matplotlib-3.7.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fbea1e762b28400393d71be1a02144aa16692a3c4c676ba0178ce83fc2928fdd", size = 7341849 },
+    { url = "https://files.pythonhosted.org/packages/94/29/39fc4acdc296dd86e09cecb65c14966e1cf18e0f091b9cbd9bd3f0c19ee4/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec0e1adc0ad70ba8227e957551e25a9d2995e319c29f94a97575bb90fa1d4469", size = 11354141 },
+    { url = "https://files.pythonhosted.org/packages/54/36/44c5eeb0d83ae1e3ed34d264d7adee947c4fd56c4a9464ce822de094995a/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6738c89a635ced486c8a20e20111d33f6398a9cbebce1ced59c211e12cd61455", size = 11457668 },
+    { url = "https://files.pythonhosted.org/packages/b7/e2/f68aeaedf0ef57cbb793637ee82e62e64ea26cee908db0fe4f8e24d502c0/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1210b7919b4ed94b5573870f316bca26de3e3b07ffdb563e79327dc0e6bba515", size = 11580088 },
+    { url = "https://files.pythonhosted.org/packages/d9/f7/7c88d34afc38943aa5e4e04d27fc9da5289a48c264c0d794f60c9cda0949/matplotlib-3.7.5-cp310-cp310-win32.whl", hash = "sha256:068ebcc59c072781d9dcdb82f0d3f1458271c2de7ca9c78f5bd672141091e9e1", size = 7339332 },
+    { url = "https://files.pythonhosted.org/packages/91/99/e5f6f7c9438279581c4a2308d264fe24dc98bb80e3b2719f797227e54ddc/matplotlib-3.7.5-cp310-cp310-win_amd64.whl", hash = "sha256:f098ffbaab9df1e3ef04e5a5586a1e6b1791380698e84938d8640961c79b1fc0", size = 7506405 },
+    { url = "https://files.pythonhosted.org/packages/5e/c6/45d0485e59d70b7a6a81eade5d0aed548b42cc65658c0ce0f813b9249165/matplotlib-3.7.5-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:f65342c147572673f02a4abec2d5a23ad9c3898167df9b47c149f32ce61ca078", size = 8325506 },
+    { url = "https://files.pythonhosted.org/packages/0e/0a/83bd8589f3597745f624fbcc7da1140088b2f4160ca51c71553c561d0df5/matplotlib-3.7.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4ddf7fc0e0dc553891a117aa083039088d8a07686d4c93fb8a810adca68810af", size = 7439905 },
+    { url = "https://files.pythonhosted.org/packages/84/c1/a7705b24f8f9b4d7ceea0002c13bae50cf9423f299f56d8c47a5cd2627d2/matplotlib-3.7.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0ccb830fc29442360d91be48527809f23a5dcaee8da5f4d9b2d5b867c1b087b8", size = 7342895 },
+    { url = "https://files.pythonhosted.org/packages/94/6e/55d7d8310c96a7459c883aa4be3f5a9338a108278484cbd5c95d480d1cef/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efc6bb28178e844d1f408dd4d6341ee8a2e906fc9e0fa3dae497da4e0cab775d", size = 11358830 },
+    { url = "https://files.pythonhosted.org/packages/55/57/3b36afe104216db1cf2f3889c394b403ea87eda77c4815227c9524462ba8/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3b15c4c2d374f249f324f46e883340d494c01768dd5287f8bc00b65b625ab56c", size = 11462575 },
+    { url = "https://files.pythonhosted.org/packages/f3/0b/fabcf5f66b12fab5c4110d06a6c0fed875c7e63bc446403f58f9dadc9999/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d028555421912307845e59e3de328260b26d055c5dac9b182cc9783854e98fb", size = 11584280 },
+    { url = "https://files.pythonhosted.org/packages/47/a9/1ad7df27a9da70b62109584632f83fe6ef45774701199c44d5777107c240/matplotlib-3.7.5-cp311-cp311-win32.whl", hash = "sha256:fe184b4625b4052fa88ef350b815559dd90cc6cc8e97b62f966e1ca84074aafa", size = 7340429 },
+    { url = "https://files.pythonhosted.org/packages/e3/b1/1b6c34b89173d6c206dc5a4028e8518b4dfee3569c13bdc0c88d0486cae7/matplotlib-3.7.5-cp311-cp311-win_amd64.whl", hash = "sha256:084f1f0f2f1010868c6f1f50b4e1c6f2fb201c58475494f1e5b66fed66093647", size = 7507112 },
+    { url = "https://files.pythonhosted.org/packages/75/dc/4e341a3ef36f3e7321aec0741317f12c7a23264be708a97972bf018c34af/matplotlib-3.7.5-cp312-cp312-macosx_10_12_universal2.whl", hash = "sha256:34bceb9d8ddb142055ff27cd7135f539f2f01be2ce0bafbace4117abe58f8fe4", size = 8323797 },
+    { url = "https://files.pythonhosted.org/packages/af/83/bbb482d678362ceb68cc59ec4fc705dde636025969361dac77be868541ef/matplotlib-3.7.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c5a2134162273eb8cdfd320ae907bf84d171de948e62180fa372a3ca7cf0f433", size = 7439549 },
+    { url = "https://files.pythonhosted.org/packages/1a/ee/e49a92d9e369b2b9e4373894171cb4e641771cd7f81bde1d8b6fb8c60842/matplotlib-3.7.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:039ad54683a814002ff37bf7981aa1faa40b91f4ff84149beb53d1eb64617980", size = 7341788 },
+    { url = "https://files.pythonhosted.org/packages/48/79/89cb2fc5ddcfc3d440a739df04dbe6e4e72b1153d1ebd32b45d42eb71d27/matplotlib-3.7.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d742ccd1b09e863b4ca58291728db645b51dab343eebb08d5d4b31b308296ce", size = 11356329 },
+    { url = "https://files.pythonhosted.org/packages/ff/25/84f181cdae5c9eba6fd1c2c35642aec47233425fe3b0d6fccdb323fb36e0/matplotlib-3.7.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:743b1c488ca6a2bc7f56079d282e44d236bf375968bfd1b7ba701fd4d0fa32d6", size = 11577813 },
+    { url = "https://files.pythonhosted.org/packages/9f/24/b2db065d40e58033b3350222fb8bbb0ffcb834029df9c1f9349dd9c7dd45/matplotlib-3.7.5-cp312-cp312-win_amd64.whl", hash = "sha256:fbf730fca3e1f23713bc1fae0a57db386e39dc81ea57dc305c67f628c1d7a342", size = 7507667 },
+    { url = "https://files.pythonhosted.org/packages/e3/72/50a38c8fd5dc845b06f8e71c9da802db44b81baabf4af8be78bb8a5622ea/matplotlib-3.7.5-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:cfff9b838531698ee40e40ea1a8a9dc2c01edb400b27d38de6ba44c1f9a8e3d2", size = 8322659 },
+    { url = "https://files.pythonhosted.org/packages/b1/ea/129163dcd21db6da5d559a8160c4a74c1dc5f96ac246a3d4248b43c7648d/matplotlib-3.7.5-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:1dbcca4508bca7847fe2d64a05b237a3dcaec1f959aedb756d5b1c67b770c5ee", size = 7438408 },
+    { url = "https://files.pythonhosted.org/packages/aa/59/4d13e5b6298b1ca5525eea8c68d3806ae93ab6d0bb17ca9846aa3156b92b/matplotlib-3.7.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4cdf4ef46c2a1609a50411b66940b31778db1e4b73d4ecc2eaa40bd588979b13", size = 7341782 },
+    { url = "https://files.pythonhosted.org/packages/9e/c4/f562df04b08487731743511ff274ae5d31dce2ff3e5621f8b070d20ab54a/matplotlib-3.7.5-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:167200ccfefd1674b60e957186dfd9baf58b324562ad1a28e5d0a6b3bea77905", size = 9196487 },
+    { url = "https://files.pythonhosted.org/packages/30/33/cc27211d2ffeee4fd7402dca137b6e8a83f6dcae3d4be8d0ad5068555561/matplotlib-3.7.5-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:53e64522934df6e1818b25fd48cf3b645b11740d78e6ef765fbb5fa5ce080d02", size = 9213051 },
+    { url = "https://files.pythonhosted.org/packages/9b/9d/8bd37c86b79312c9dbcfa379dec32303f9b38e8456e0829d7e666a0e0a05/matplotlib-3.7.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3e3bc79b2d7d615067bd010caff9243ead1fc95cf735c16e4b2583173f717eb", size = 11370807 },
+    { url = "https://files.pythonhosted.org/packages/c0/1e/b24a07a849c8d458f1b3724f49029f0dedf748bdedb4d5f69491314838b6/matplotlib-3.7.5-cp38-cp38-win32.whl", hash = "sha256:6b641b48c6819726ed47c55835cdd330e53747d4efff574109fd79b2d8a13748", size = 7340461 },
+    { url = "https://files.pythonhosted.org/packages/16/51/58b0b9de42fe1e665736d9286f88b5f1556a0e22bed8a71f468231761083/matplotlib-3.7.5-cp38-cp38-win_amd64.whl", hash = "sha256:f0b60993ed3488b4532ec6b697059897891927cbfc2b8d458a891b60ec03d9d7", size = 7507471 },
+    { url = "https://files.pythonhosted.org/packages/0d/00/17487e9e8949ca623af87f6c8767408efe7530b7e1f4d6897fa7fa940834/matplotlib-3.7.5-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:090964d0afaff9c90e4d8de7836757e72ecfb252fb02884016d809239f715651", size = 8323175 },
+    { url = "https://files.pythonhosted.org/packages/6a/84/be0acd521fa9d6697657cf35878153f8009a42b4b75237aebc302559a8a9/matplotlib-3.7.5-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:9fc6fcfbc55cd719bc0bfa60bde248eb68cf43876d4c22864603bdd23962ba25", size = 7438737 },
+    { url = "https://files.pythonhosted.org/packages/17/39/175f36a6d68d0cf47a4fecbae9728048355df23c9feca8688f1476b198e6/matplotlib-3.7.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5e7cc3078b019bb863752b8b60e8b269423000f1603cb2299608231996bd9d54", size = 7341916 },
+    { url = "https://files.pythonhosted.org/packages/36/c0/9a1c2a79f85c15d41b60877cbc333694ed80605e5c97a33880c4ecfd5bf1/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e4e9a868e8163abaaa8259842d85f949a919e1ead17644fb77a60427c90473c", size = 11352264 },
+    { url = "https://files.pythonhosted.org/packages/a6/39/b0204e0e7a899b0676733366a55ccafa723799b719bc7f2e85e5ecde26a0/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fa7ebc995a7d747dacf0a717d0eb3aa0f0c6a0e9ea88b0194d3a3cd241a1500f", size = 11454722 },
+    { url = "https://files.pythonhosted.org/packages/d8/39/64dd1d36c79e72e614977db338d180cf204cf658927c05a8ef2d47feb4c0/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3785bfd83b05fc0e0c2ae4c4a90034fe693ef96c679634756c50fe6efcc09856", size = 11576343 },
+    { url = "https://files.pythonhosted.org/packages/31/b4/e77bc11394d858bdf15e356980fceb4ac9604b0fa8212ef3ca4f1dc166b8/matplotlib-3.7.5-cp39-cp39-win32.whl", hash = "sha256:29b058738c104d0ca8806395f1c9089dfe4d4f0f78ea765c6c704469f3fffc81", size = 7340455 },
+    { url = "https://files.pythonhosted.org/packages/4a/84/081820c596b9555ecffc6819ee71f847f2fbb0d7c70a42c1eeaa54edf3e0/matplotlib-3.7.5-cp39-cp39-win_amd64.whl", hash = "sha256:fd4028d570fa4b31b7b165d4a685942ae9cdc669f33741e388c01857d9723eab", size = 7507711 },
+    { url = "https://files.pythonhosted.org/packages/27/6c/1bb10f3d6f337b9faa2e96a251bd87ba5fed85a608df95eb4d69acc109f0/matplotlib-3.7.5-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2a9a3f4d6a7f88a62a6a18c7e6a84aedcaf4faf0708b4ca46d87b19f1b526f88", size = 7397285 },
+    { url = "https://files.pythonhosted.org/packages/b2/36/66cfea213e9ba91cda9e257542c249ed235d49021af71c2e8007107d7d4c/matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9b3fd853d4a7f008a938df909b96db0b454225f935d3917520305b90680579c", size = 7552612 },
+    { url = "https://files.pythonhosted.org/packages/77/df/16655199bf984c37c6a816b854bc032b56aef521aadc04f27928422f3c91/matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0ad550da9f160737d7890217c5eeed4337d07e83ca1b2ca6535078f354e7675", size = 7515564 },
+    { url = "https://files.pythonhosted.org/packages/5b/c8/3534c3705a677b71abb6be33609ba129fdeae2ea4e76b2fd3ab62c86fab3/matplotlib-3.7.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:20da7924a08306a861b3f2d1da0d1aa9a6678e480cf8eacffe18b565af2813e7", size = 7521336 },
+    { url = "https://files.pythonhosted.org/packages/20/a0/c5c0d410798b387ed3a177a5a7eba21055dd9c41d4b15bd0861241a5a60e/matplotlib-3.7.5-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b45c9798ea6bb920cb77eb7306409756a7fab9db9b463e462618e0559aecb30e", size = 7397931 },
+    { url = "https://files.pythonhosted.org/packages/c3/2f/9e9509727d4c7d1b8e2c88e9330a97d54a1dd20bd316a0c8d2f8b38c4513/matplotlib-3.7.5-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a99866267da1e561c7776fe12bf4442174b79aac1a47bd7e627c7e4d077ebd83", size = 7553224 },
+    { url = "https://files.pythonhosted.org/packages/89/0c/5f3e403dcf5c23799c92b0139dd00e41caf23983e9281f5bfeba3065e7d2/matplotlib-3.7.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b6aa62adb6c268fc87d80f963aca39c64615c31830b02697743c95590ce3fbb", size = 7513250 },
+    { url = "https://files.pythonhosted.org/packages/87/e0/03eba0a8c3775ef910dbb3a287114a64c47abbcaeab2543c59957f155a86/matplotlib-3.7.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:e530ab6a0afd082d2e9c17eb1eb064a63c5b09bb607b2b74fa41adbe3e162286", size = 7521729 },
+]
+
+[[package]]
+name = "mypy"
+version = "1.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mypy-extensions" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e8/21/7e9e523537991d145ab8a0a2fd98548d67646dc2aaaf6091c31ad883e7c1/mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e", size = 3152532 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5e/8c/206de95a27722b5b5a8c85ba3100467bd86299d92a4f71c6b9aa448bfa2f/mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a", size = 11020731 },
+    { url = "https://files.pythonhosted.org/packages/ab/bb/b31695a29eea76b1569fd28b4ab141a1adc9842edde080d1e8e1776862c7/mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80", size = 10184276 },
+    { url = "https://files.pythonhosted.org/packages/a5/2d/4a23849729bb27934a0e079c9c1aad912167d875c7b070382a408d459651/mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7", size = 12587706 },
+    { url = "https://files.pythonhosted.org/packages/5c/c3/d318e38ada50255e22e23353a469c791379825240e71b0ad03e76ca07ae6/mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f", size = 13105586 },
+    { url = "https://files.pythonhosted.org/packages/4a/25/3918bc64952370c3dbdbd8c82c363804678127815febd2925b7273d9482c/mypy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:c5fc54dbb712ff5e5a0fca797e6e0aa25726c7e72c6a5850cfd2adbc1eb0a372", size = 9632318 },
+    { url = "https://files.pythonhosted.org/packages/d0/19/de0822609e5b93d02579075248c7aa6ceaddcea92f00bf4ea8e4c22e3598/mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d", size = 10939027 },
+    { url = "https://files.pythonhosted.org/packages/c8/71/6950fcc6ca84179137e4cbf7cf41e6b68b4a339a1f5d3e954f8c34e02d66/mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d", size = 10108699 },
+    { url = "https://files.pythonhosted.org/packages/26/50/29d3e7dd166e74dc13d46050b23f7d6d7533acf48f5217663a3719db024e/mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b", size = 12506263 },
+    { url = "https://files.pythonhosted.org/packages/3f/1d/676e76f07f7d5ddcd4227af3938a9c9640f293b7d8a44dd4ff41d4db25c1/mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73", size = 12984688 },
+    { url = "https://files.pythonhosted.org/packages/9c/03/5a85a30ae5407b1d28fab51bd3e2103e52ad0918d1e68f02a7778669a307/mypy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51f869f4b6b538229c1d1bcc1dd7d119817206e2bc54e8e374b3dfa202defcca", size = 9626811 },
+    { url = "https://files.pythonhosted.org/packages/fb/31/c526a7bd2e5c710ae47717c7a5f53f616db6d9097caf48ad650581e81748/mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5", size = 11077900 },
+    { url = "https://files.pythonhosted.org/packages/83/67/b7419c6b503679d10bd26fc67529bc6a1f7a5f220bbb9f292dc10d33352f/mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e", size = 10074818 },
+    { url = "https://files.pythonhosted.org/packages/ba/07/37d67048786ae84e6612575e173d713c9a05d0ae495dde1e68d972207d98/mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2", size = 12589275 },
+    { url = "https://files.pythonhosted.org/packages/1f/17/b1018c6bb3e9f1ce3956722b3bf91bff86c1cefccca71cec05eae49d6d41/mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0", size = 13037783 },
+    { url = "https://files.pythonhosted.org/packages/cb/32/cd540755579e54a88099aee0287086d996f5a24281a673f78a0e14dba150/mypy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0affb3a79a256b4183ba09811e3577c5163ed06685e4d4b46429a271ba174d2", size = 9726197 },
+    { url = "https://files.pythonhosted.org/packages/11/bb/ab4cfdc562cad80418f077d8be9b4491ee4fb257440da951b85cbb0a639e/mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7", size = 11069721 },
+    { url = "https://files.pythonhosted.org/packages/59/3b/a393b1607cb749ea2c621def5ba8c58308ff05e30d9dbdc7c15028bca111/mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62", size = 10063996 },
+    { url = "https://files.pythonhosted.org/packages/d1/1f/6b76be289a5a521bb1caedc1f08e76ff17ab59061007f201a8a18cc514d1/mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8", size = 12584043 },
+    { url = "https://files.pythonhosted.org/packages/a6/83/5a85c9a5976c6f96e3a5a7591aa28b4a6ca3a07e9e5ba0cec090c8b596d6/mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7", size = 13036996 },
+    { url = "https://files.pythonhosted.org/packages/b4/59/c39a6f752f1f893fccbcf1bdd2aca67c79c842402b5283563d006a67cf76/mypy-1.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:9f73dba9ec77acb86457a8fc04b5239822df0c14a082564737833d2963677dbc", size = 9737709 },
+    { url = "https://files.pythonhosted.org/packages/5e/2a/13e9ad339131c0fba5c70584f639005a47088f5eed77081a3d00479df0ca/mypy-1.13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:100fac22ce82925f676a734af0db922ecfea991e1d7ec0ceb1e115ebe501301a", size = 10955147 },
+    { url = "https://files.pythonhosted.org/packages/94/39/02929067dc16b72d78109195cfed349ac4ec85f3d52517ac62b9a5263685/mypy-1.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7bcb0bb7f42a978bb323a7c88f1081d1b5dee77ca86f4100735a6f541299d8fb", size = 10138373 },
+    { url = "https://files.pythonhosted.org/packages/4a/cc/066709bb01734e3dbbd1375749f8789bf9693f8b842344fc0cf52109694f/mypy-1.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bde31fc887c213e223bbfc34328070996061b0833b0a4cfec53745ed61f3519b", size = 12543621 },
+    { url = "https://files.pythonhosted.org/packages/f5/a2/124df839025348c7b9877d0ce134832a9249968e3ab36bb826bab0e9a1cf/mypy-1.13.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:07de989f89786f62b937851295ed62e51774722e5444a27cecca993fc3f9cd74", size = 13050348 },
+    { url = "https://files.pythonhosted.org/packages/45/86/cc94b1e7f7e756a63043cf425c24fb7470013ee1c032180282db75b1b335/mypy-1.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:4bde84334fbe19bad704b3f5b78c4abd35ff1026f8ba72b29de70dda0916beb6", size = 9615311 },
+    { url = "https://files.pythonhosted.org/packages/5f/d4/b33ddd40dad230efb317898a2d1c267c04edba73bc5086bf77edeb410fb2/mypy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0246bcb1b5de7f08f2826451abd947bf656945209b140d16ed317f65a17dc7dc", size = 11013906 },
+    { url = "https://files.pythonhosted.org/packages/f4/e6/f414bca465b44d01cd5f4a82761e15044bedd1bf8025c5af3cc64518fac5/mypy-1.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f5b7deae912cf8b77e990b9280f170381fdfbddf61b4ef80927edd813163732", size = 10180657 },
+    { url = "https://files.pythonhosted.org/packages/38/e9/fc3865e417722f98d58409770be01afb961e2c1f99930659ff4ae7ca8b7e/mypy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7029881ec6ffb8bc233a4fa364736789582c738217b133f1b55967115288a2bc", size = 12586394 },
+    { url = "https://files.pythonhosted.org/packages/2e/35/f4d8b6d2cb0b3dad63e96caf159419dda023f45a358c6c9ac582ccaee354/mypy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3e38b980e5681f28f033f3be86b099a247b13c491f14bb8b1e1e134d23bb599d", size = 13103591 },
+    { url = "https://files.pythonhosted.org/packages/22/1d/80594aef135f921dd52e142fa0acd19df197690bd0cde42cea7b88cf5aa2/mypy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a6789be98a2017c912ae6ccb77ea553bbaf13d27605d2ca20a76dfbced631b24", size = 9634690 },
+    { url = "https://files.pythonhosted.org/packages/3b/86/72ce7f57431d87a7ff17d442f521146a6585019eb8f4f31b7c02801f78ad/mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a", size = 2647043 },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 },
+]
+
+[[package]]
+name = "networkx"
+version = "3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/a1/47b974da1a73f063c158a1f4cc33ed0abf7c04f98a19050e80c533c31f0c/networkx-3.1.tar.gz", hash = "sha256:de346335408f84de0eada6ff9fafafff9bcda11f0a0dfaa931133debb146ab61", size = 2021691 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/05/9d4f9b78ead6b2661d6e8ea772e111fc4a9fbd866ad0c81906c11206b55e/networkx-3.1-py3-none-any.whl", hash = "sha256:4f33f68cb2afcf86f28a45f43efc27a9386b535d567d2127f8f61d51dec58d36", size = 2072251 },
+]
+
+[[package]]
+name = "numpy"
+version = "1.24.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/9b/027bec52c633f6556dba6b722d9a0befb40498b9ceddd29cbe67a45a127c/numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463", size = 10911229 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/80/6cdfb3e275d95155a34659163b83c09e3a3ff9f1456880bec6cc63d71083/numpy-1.24.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0bfb52d2169d58c1cdb8cc1f16989101639b34c7d3ce60ed70b19c63eba0b64", size = 19789140 },
+    { url = "https://files.pythonhosted.org/packages/64/5f/3f01d753e2175cfade1013eea08db99ba1ee4bdb147ebcf3623b75d12aa7/numpy-1.24.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ed094d4f0c177b1b8e7aa9cba7d6ceed51c0e569a5318ac0ca9a090680a6a1b1", size = 13854297 },
+    { url = "https://files.pythonhosted.org/packages/5a/b3/2f9c21d799fa07053ffa151faccdceeb69beec5a010576b8991f614021f7/numpy-1.24.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79fc682a374c4a8ed08b331bef9c5f582585d1048fa6d80bc6c35bc384eee9b4", size = 13995611 },
+    { url = "https://files.pythonhosted.org/packages/10/be/ae5bf4737cb79ba437879915791f6f26d92583c738d7d960ad94e5c36adf/numpy-1.24.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ffe43c74893dbf38c2b0a1f5428760a1a9c98285553c89e12d70a96a7f3a4d6", size = 17282357 },
+    { url = "https://files.pythonhosted.org/packages/c0/64/908c1087be6285f40e4b3e79454552a701664a079321cff519d8c7051d06/numpy-1.24.4-cp310-cp310-win32.whl", hash = "sha256:4c21decb6ea94057331e111a5bed9a79d335658c27ce2adb580fb4d54f2ad9bc", size = 12429222 },
+    { url = "https://files.pythonhosted.org/packages/22/55/3d5a7c1142e0d9329ad27cece17933b0e2ab4e54ddc5c1861fbfeb3f7693/numpy-1.24.4-cp310-cp310-win_amd64.whl", hash = "sha256:b4bea75e47d9586d31e892a7401f76e909712a0fd510f58f5337bea9572c571e", size = 14841514 },
+    { url = "https://files.pythonhosted.org/packages/a9/cc/5ed2280a27e5dab12994c884f1f4d8c3bd4d885d02ae9e52a9d213a6a5e2/numpy-1.24.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f136bab9c2cfd8da131132c2cf6cc27331dd6fae65f95f69dcd4ae3c3639c810", size = 19775508 },
+    { url = "https://files.pythonhosted.org/packages/c0/bc/77635c657a3668cf652806210b8662e1aff84b818a55ba88257abf6637a8/numpy-1.24.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2926dac25b313635e4d6cf4dc4e51c8c0ebfed60b801c799ffc4c32bf3d1254", size = 13840033 },
+    { url = "https://files.pythonhosted.org/packages/a7/4c/96cdaa34f54c05e97c1c50f39f98d608f96f0677a6589e64e53104e22904/numpy-1.24.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:222e40d0e2548690405b0b3c7b21d1169117391c2e82c378467ef9ab4c8f0da7", size = 13991951 },
+    { url = "https://files.pythonhosted.org/packages/22/97/dfb1a31bb46686f09e68ea6ac5c63fdee0d22d7b23b8f3f7ea07712869ef/numpy-1.24.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7215847ce88a85ce39baf9e89070cb860c98fdddacbaa6c0da3ffb31b3350bd5", size = 17278923 },
+    { url = "https://files.pythonhosted.org/packages/35/e2/76a11e54139654a324d107da1d98f99e7aa2a7ef97cfd7c631fba7dbde71/numpy-1.24.4-cp311-cp311-win32.whl", hash = "sha256:4979217d7de511a8d57f4b4b5b2b965f707768440c17cb70fbf254c4b225238d", size = 12422446 },
+    { url = "https://files.pythonhosted.org/packages/d8/ec/ebef2f7d7c28503f958f0f8b992e7ce606fb74f9e891199329d5f5f87404/numpy-1.24.4-cp311-cp311-win_amd64.whl", hash = "sha256:b7b1fc9864d7d39e28f41d089bfd6353cb5f27ecd9905348c24187a768c79694", size = 14834466 },
+    { url = "https://files.pythonhosted.org/packages/11/10/943cfb579f1a02909ff96464c69893b1d25be3731b5d3652c2e0cf1281ea/numpy-1.24.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1452241c290f3e2a312c137a9999cdbf63f78864d63c79039bda65ee86943f61", size = 19780722 },
+    { url = "https://files.pythonhosted.org/packages/a7/ae/f53b7b265fdc701e663fbb322a8e9d4b14d9cb7b2385f45ddfabfc4327e4/numpy-1.24.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:04640dab83f7c6c85abf9cd729c5b65f1ebd0ccf9de90b270cd61935eef0197f", size = 13843102 },
+    { url = "https://files.pythonhosted.org/packages/25/6f/2586a50ad72e8dbb1d8381f837008a0321a3516dfd7cb57fc8cf7e4bb06b/numpy-1.24.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5425b114831d1e77e4b5d812b69d11d962e104095a5b9c3b641a218abcc050e", size = 14039616 },
+    { url = "https://files.pythonhosted.org/packages/98/5d/5738903efe0ecb73e51eb44feafba32bdba2081263d40c5043568ff60faf/numpy-1.24.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd80e219fd4c71fc3699fc1dadac5dcf4fd882bfc6f7ec53d30fa197b8ee22dc", size = 17316263 },
+    { url = "https://files.pythonhosted.org/packages/d1/57/8d328f0b91c733aa9aa7ee540dbc49b58796c862b4fbcb1146c701e888da/numpy-1.24.4-cp38-cp38-win32.whl", hash = "sha256:4602244f345453db537be5314d3983dbf5834a9701b7723ec28923e2889e0bb2", size = 12455660 },
+    { url = "https://files.pythonhosted.org/packages/69/65/0d47953afa0ad569d12de5f65d964321c208492064c38fe3b0b9744f8d44/numpy-1.24.4-cp38-cp38-win_amd64.whl", hash = "sha256:692f2e0f55794943c5bfff12b3f56f99af76f902fc47487bdfe97856de51a706", size = 14868112 },
+    { url = "https://files.pythonhosted.org/packages/9a/cd/d5b0402b801c8a8b56b04c1e85c6165efab298d2f0ab741c2406516ede3a/numpy-1.24.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2541312fbf09977f3b3ad449c4e5f4bb55d0dbf79226d7724211acc905049400", size = 19816549 },
+    { url = "https://files.pythonhosted.org/packages/14/27/638aaa446f39113a3ed38b37a66243e21b38110d021bfcb940c383e120f2/numpy-1.24.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9667575fb6d13c95f1b36aca12c5ee3356bf001b714fc354eb5465ce1609e62f", size = 13879950 },
+    { url = "https://files.pythonhosted.org/packages/8f/27/91894916e50627476cff1a4e4363ab6179d01077d71b9afed41d9e1f18bf/numpy-1.24.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a86ed21e4f87050382c7bc96571755193c4c1392490744ac73d660e8f564a9", size = 14030228 },
+    { url = "https://files.pythonhosted.org/packages/7a/7c/d7b2a0417af6428440c0ad7cb9799073e507b1a465f827d058b826236964/numpy-1.24.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d11efb4dbecbdf22508d55e48d9c8384db795e1b7b51ea735289ff96613ff74d", size = 17311170 },
+    { url = "https://files.pythonhosted.org/packages/18/9d/e02ace5d7dfccee796c37b995c63322674daf88ae2f4a4724c5dd0afcc91/numpy-1.24.4-cp39-cp39-win32.whl", hash = "sha256:6620c0acd41dbcb368610bb2f4d83145674040025e5536954782467100aa8835", size = 12454918 },
+    { url = "https://files.pythonhosted.org/packages/63/38/6cc19d6b8bfa1d1a459daf2b3fe325453153ca7019976274b6f33d8b5663/numpy-1.24.4-cp39-cp39-win_amd64.whl", hash = "sha256:befe2bf740fd8373cf56149a5c23a0f601e82869598d41f8e188a0e9869926f8", size = 14867441 },
+    { url = "https://files.pythonhosted.org/packages/a4/fd/8dff40e25e937c94257455c237b9b6bf5a30d42dd1cc11555533be099492/numpy-1.24.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:31f13e25b4e304632a4619d0e0777662c2ffea99fcae2029556b17d8ff958aef", size = 19156590 },
+    { url = "https://files.pythonhosted.org/packages/42/e7/4bf953c6e05df90c6d351af69966384fed8e988d0e8c54dad7103b59f3ba/numpy-1.24.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95f7ac6540e95bc440ad77f56e520da5bf877f87dca58bd095288dce8940532a", size = 16705744 },
+    { url = "https://files.pythonhosted.org/packages/fc/dd/9106005eb477d022b60b3817ed5937a43dad8fd1f20b0610ea8a32fcb407/numpy-1.24.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e98f220aa76ca2a977fe435f5b04d7b3470c0a2e6312907b37ba6068f26787f2", size = 14734290 },
+]
+
+[[package]]
+name = "opencv-python"
+version = "4.10.0.84"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/b70a2d9ab205110d715906fc8ec83fbb00404aeb3a37a0654fdb68eb0c8c/opencv-python-4.10.0.84.tar.gz", hash = "sha256:72d234e4582e9658ffea8e9cae5b63d488ad06994ef12d81dc303b17472f3526", size = 95103981 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/66/82/564168a349148298aca281e342551404ef5521f33fba17b388ead0a84dc5/opencv_python-4.10.0.84-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:fc182f8f4cda51b45f01c64e4cbedfc2f00aff799debebc305d8d0210c43f251", size = 54835524 },
+    { url = "https://files.pythonhosted.org/packages/64/4a/016cda9ad7cf18c58ba074628a4eaae8aa55f3fd06a266398cef8831a5b9/opencv_python-4.10.0.84-cp37-abi3-macosx_12_0_x86_64.whl", hash = "sha256:71e575744f1d23f79741450254660442785f45a0797212852ee5199ef12eed98", size = 56475426 },
+    { url = "https://files.pythonhosted.org/packages/81/e4/7a987ebecfe5ceaf32db413b67ff18eb3092c598408862fff4d7cc3fd19b/opencv_python-4.10.0.84-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09a332b50488e2dda866a6c5573ee192fe3583239fb26ff2f7f9ceb0bc119ea6", size = 41746971 },
+    { url = "https://files.pythonhosted.org/packages/3f/a4/d2537f47fd7fcfba966bd806e3ec18e7ee1681056d4b0a9c8d983983e4d5/opencv_python-4.10.0.84-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ace140fc6d647fbe1c692bcb2abce768973491222c067c131d80957c595b71f", size = 62548253 },
+    { url = "https://files.pythonhosted.org/packages/1e/39/bbf57e7b9dab623e8773f6ff36385456b7ae7fa9357a5e53db732c347eac/opencv_python-4.10.0.84-cp37-abi3-win32.whl", hash = "sha256:2db02bb7e50b703f0a2d50c50ced72e95c574e1e5a0bb35a8a86d0b35c98c236", size = 28737688 },
+    { url = "https://files.pythonhosted.org/packages/ec/6c/fab8113424af5049f85717e8e527ca3773299a3c6b02506e66436e19874f/opencv_python-4.10.0.84-cp37-abi3-win_amd64.whl", hash = "sha256:32dbbd94c26f611dc5cc6979e6b7aa1f55a64d6b463cc1dcd3c95505a63e48fe", size = 38842521 },
+]
+
+[[package]]
+name = "opencv-python-headless"
+version = "4.10.0.84"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2f/7e/d20f68a5f1487adf19d74378d349932a386b1ece3be9be9915e5986db468/opencv-python-headless-4.10.0.84.tar.gz", hash = "sha256:f2017c6101d7c2ef8d7bc3b414c37ff7f54d64413a1847d89970b6b7069b4e1a", size = 95117755 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1c/9b/583c8d9259f6fc19413f83fd18dd8e6cbc8eefb0b4dc6da52dd151fe3272/opencv_python_headless-4.10.0.84-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:a4f4bcb07d8f8a7704d9c8564c224c8b064c63f430e95b61ac0bffaa374d330e", size = 54835657 },
+    { url = "https://files.pythonhosted.org/packages/c0/7b/b4c67f5dad7a9a61c47f7a39e4050e8a4628bd64b3c3daaeb755d759f928/opencv_python_headless-4.10.0.84-cp37-abi3-macosx_12_0_x86_64.whl", hash = "sha256:5ae454ebac0eb0a0b932e3406370aaf4212e6a3fdb5038cc86c7aea15a6851da", size = 56475470 },
+    { url = "https://files.pythonhosted.org/packages/91/61/f838ce2046f3ec3591ea59ea3549085e399525d3b4558c4ed60b55ed88c0/opencv_python_headless-4.10.0.84-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46071015ff9ab40fccd8a163da0ee14ce9846349f06c6c8c0f2870856ffa45db", size = 29329705 },
+    { url = "https://files.pythonhosted.org/packages/d1/09/248f86a404567303cdf120e4a301f389b68e3b18e5c0cc428de327da609c/opencv_python_headless-4.10.0.84-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:377d08a7e48a1405b5e84afcbe4798464ce7ee17081c1c23619c8b398ff18295", size = 49858781 },
+    { url = "https://files.pythonhosted.org/packages/30/c0/66f88d58500e990a9a0a5c06f98862edf1d0a3a430781218a8c193948438/opencv_python_headless-4.10.0.84-cp37-abi3-win32.whl", hash = "sha256:9092404b65458ed87ce932f613ffbb1106ed2c843577501e5768912360fc50ec", size = 28675298 },
+    { url = "https://files.pythonhosted.org/packages/26/d0/22f68eb23eea053a31655960f133c0be9726c6a881547e6e9e7e2a946c4f/opencv_python_headless-4.10.0.84-cp37-abi3-win_amd64.whl", hash = "sha256:afcf28bd1209dd58810d33defb622b325d3cbe49dcd7a43a902982c33e5fad05", size = 38754031 },
+]
+
+[[package]]
+name = "packaging"
+version = "24.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
+]
+
+[[package]]
+name = "pandas"
+version = "2.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/a7/824332581e258b5aa4f3763ecb2a797e5f9a54269044ba2e50ac19936b32/pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c", size = 5284455 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/b2/0d4a5729ce1ce11630c4fc5d5522a33b967b3ca146c210f58efde7c40e99/pandas-2.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c7c9f27a4185304c7caf96dc7d91bc60bc162221152de697c98eb0b2648dd8", size = 11760908 },
+    { url = "https://files.pythonhosted.org/packages/4a/f6/f620ca62365d83e663a255a41b08d2fc2eaf304e0b8b21bb6d62a7390fe3/pandas-2.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f167beed68918d62bffb6ec64f2e1d8a7d297a038f86d4aed056b9493fca407f", size = 10823486 },
+    { url = "https://files.pythonhosted.org/packages/c2/59/cb4234bc9b968c57e81861b306b10cd8170272c57b098b724d3de5eda124/pandas-2.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce0c6f76a0f1ba361551f3e6dceaff06bde7514a374aa43e33b588ec10420183", size = 11571897 },
+    { url = "https://files.pythonhosted.org/packages/e3/59/35a2892bf09ded9c1bf3804461efe772836a5261ef5dfb4e264ce813ff99/pandas-2.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba619e410a21d8c387a1ea6e8a0e49bb42216474436245718d7f2e88a2f8d7c0", size = 12306421 },
+    { url = "https://files.pythonhosted.org/packages/94/71/3a0c25433c54bb29b48e3155b959ac78f4c4f2f06f94d8318aac612cb80f/pandas-2.0.3-cp310-cp310-win32.whl", hash = "sha256:3ef285093b4fe5058eefd756100a367f27029913760773c8bf1d2d8bebe5d210", size = 9540792 },
+    { url = "https://files.pythonhosted.org/packages/ed/30/b97456e7063edac0e5a405128065f0cd2033adfe3716fb2256c186bd41d0/pandas-2.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:9ee1a69328d5c36c98d8e74db06f4ad518a1840e8ccb94a4ba86920986bb617e", size = 10664333 },
+    { url = "https://files.pythonhosted.org/packages/b3/92/a5e5133421b49e901a12e02a6a7ef3a0130e10d13db8cb657fdd0cba3b90/pandas-2.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b084b91d8d66ab19f5bb3256cbd5ea661848338301940e17f4492b2ce0801fe8", size = 11645672 },
+    { url = "https://files.pythonhosted.org/packages/8f/bb/aea1fbeed5b474cb8634364718abe9030d7cc7a30bf51f40bd494bbc89a2/pandas-2.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37673e3bdf1551b95bf5d4ce372b37770f9529743d2498032439371fc7b7eb26", size = 10693229 },
+    { url = "https://files.pythonhosted.org/packages/d6/90/e7d387f1a416b14e59290baa7a454a90d719baebbf77433ff1bdcc727800/pandas-2.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9cb1e14fdb546396b7e1b923ffaeeac24e4cedd14266c3497216dd4448e4f2d", size = 11581591 },
+    { url = "https://files.pythonhosted.org/packages/d0/28/88b81881c056376254618fad622a5e94b5126db8c61157ea1910cd1c040a/pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d9cd88488cceb7635aebb84809d087468eb33551097d600c6dad13602029c2df", size = 12219370 },
+    { url = "https://files.pythonhosted.org/packages/e4/a5/212b9039e25bf8ebb97e417a96660e3dc925dacd3f8653d531b8f7fd9be4/pandas-2.0.3-cp311-cp311-win32.whl", hash = "sha256:694888a81198786f0e164ee3a581df7d505024fbb1f15202fc7db88a71d84ebd", size = 9482935 },
+    { url = "https://files.pythonhosted.org/packages/9e/71/756a1be6bee0209d8c0d8c5e3b9fc72c00373f384a4017095ec404aec3ad/pandas-2.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6a21ab5c89dcbd57f78d0ae16630b090eec626360085a4148693def5452d8a6b", size = 10607692 },
+    { url = "https://files.pythonhosted.org/packages/78/a8/07dd10f90ca915ed914853cd57f79bfc22e1ef4384ab56cb4336d2fc1f2a/pandas-2.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4da0d45e7f34c069fe4d522359df7d23badf83abc1d1cef398895822d11061", size = 11653303 },
+    { url = "https://files.pythonhosted.org/packages/53/c3/f8e87361f7fdf42012def602bfa2a593423c729f5cb7c97aed7f51be66ac/pandas-2.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:32fca2ee1b0d93dd71d979726b12b61faa06aeb93cf77468776287f41ff8fdc5", size = 10710932 },
+    { url = "https://files.pythonhosted.org/packages/a7/87/828d50c81ce0f434163bf70b925a0eec6076808e0bca312a79322b141f66/pandas-2.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:258d3624b3ae734490e4d63c430256e716f488c4fcb7c8e9bde2d3aa46c29089", size = 11684018 },
+    { url = "https://files.pythonhosted.org/packages/f8/7f/5b047effafbdd34e52c9e2d7e44f729a0655efafb22198c45cf692cdc157/pandas-2.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eae3dc34fa1aa7772dd3fc60270d13ced7346fcbcfee017d3132ec625e23bb0", size = 12353723 },
+    { url = "https://files.pythonhosted.org/packages/ea/ae/26a2eda7fa581347d69e51f93892493b2074ef3352ac71033c9f32c52389/pandas-2.0.3-cp38-cp38-win32.whl", hash = "sha256:f3421a7afb1a43f7e38e82e844e2bca9a6d793d66c1a7f9f0ff39a795bbc5e02", size = 9646403 },
+    { url = "https://files.pythonhosted.org/packages/c3/6c/ea362eef61f05553aaf1a24b3e96b2d0603f5dc71a3bd35688a24ed88843/pandas-2.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:69d7f3884c95da3a31ef82b7618af5710dba95bb885ffab339aad925c3e8ce78", size = 10777638 },
+    { url = "https://files.pythonhosted.org/packages/f8/c7/cfef920b7b457dff6928e824896cb82367650ea127d048ee0b820026db4f/pandas-2.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5247fb1ba347c1261cbbf0fcfba4a3121fbb4029d95d9ef4dc45406620b25c8b", size = 11834160 },
+    { url = "https://files.pythonhosted.org/packages/6c/1c/689c9d99bc4e5d366a5fd871f0bcdee98a6581e240f96b78d2d08f103774/pandas-2.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:81af086f4543c9d8bb128328b5d32e9986e0c84d3ee673a2ac6fb57fd14f755e", size = 10862752 },
+    { url = "https://files.pythonhosted.org/packages/cc/b8/4d082f41c27c95bf90485d1447b647cc7e5680fea75e315669dc6e4cb398/pandas-2.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1994c789bf12a7c5098277fb43836ce090f1073858c10f9220998ac74f37c69b", size = 11715852 },
+    { url = "https://files.pythonhosted.org/packages/9e/0d/91a9fd2c202f2b1d97a38ab591890f86480ecbb596cbc56d035f6f23fdcc/pandas-2.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ec591c48e29226bcbb316e0c1e9423622bc7a4eaf1ef7c3c9fa1a3981f89641", size = 12398496 },
+    { url = "https://files.pythonhosted.org/packages/26/7d/d8aa0a2c4f3f5f8ea59fb946c8eafe8f508090ca73e2b08a9af853c1103e/pandas-2.0.3-cp39-cp39-win32.whl", hash = "sha256:04dbdbaf2e4d46ca8da896e1805bc04eb85caa9a82e259e8eed00254d5e0c682", size = 9630766 },
+    { url = "https://files.pythonhosted.org/packages/9a/f2/0ad053856debbe90c83de1b4f05915f85fd2146f20faf9daa3b320d36df3/pandas-2.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:1168574b036cd8b93abc746171c9b4f1b83467438a5e45909fed645cf8692dbc", size = 10755902 },
+]
+
+[[package]]
+name = "pillow"
+version = "10.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/74/ad3d526f3bf7b6d3f408b73fde271ec69dfac8b81341a318ce825f2b3812/pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06", size = 46555059 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/69/a31cccd538ca0b5272be2a38347f8839b97a14be104ea08b0db92f749c74/pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e", size = 3509271 },
+    { url = "https://files.pythonhosted.org/packages/9a/9e/4143b907be8ea0bce215f2ae4f7480027473f8b61fcedfda9d851082a5d2/pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d", size = 3375658 },
+    { url = "https://files.pythonhosted.org/packages/8a/25/1fc45761955f9359b1169aa75e241551e74ac01a09f487adaaf4c3472d11/pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856", size = 4332075 },
+    { url = "https://files.pythonhosted.org/packages/5e/dd/425b95d0151e1d6c951f45051112394f130df3da67363b6bc75dc4c27aba/pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f", size = 4444808 },
+    { url = "https://files.pythonhosted.org/packages/b1/84/9a15cc5726cbbfe7f9f90bfb11f5d028586595907cd093815ca6644932e3/pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b", size = 4356290 },
+    { url = "https://files.pythonhosted.org/packages/b5/5b/6651c288b08df3b8c1e2f8c1152201e0b25d240e22ddade0f1e242fc9fa0/pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc", size = 4525163 },
+    { url = "https://files.pythonhosted.org/packages/07/8b/34854bf11a83c248505c8cb0fcf8d3d0b459a2246c8809b967963b6b12ae/pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e", size = 4463100 },
+    { url = "https://files.pythonhosted.org/packages/78/63/0632aee4e82476d9cbe5200c0cdf9ba41ee04ed77887432845264d81116d/pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46", size = 4592880 },
+    { url = "https://files.pythonhosted.org/packages/df/56/b8663d7520671b4398b9d97e1ed9f583d4afcbefbda3c6188325e8c297bd/pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984", size = 2235218 },
+    { url = "https://files.pythonhosted.org/packages/f4/72/0203e94a91ddb4a9d5238434ae6c1ca10e610e8487036132ea9bf806ca2a/pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141", size = 2554487 },
+    { url = "https://files.pythonhosted.org/packages/bd/52/7e7e93d7a6e4290543f17dc6f7d3af4bd0b3dd9926e2e8a35ac2282bc5f4/pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1", size = 2243219 },
+    { url = "https://files.pythonhosted.org/packages/a7/62/c9449f9c3043c37f73e7487ec4ef0c03eb9c9afc91a92b977a67b3c0bbc5/pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c", size = 3509265 },
+    { url = "https://files.pythonhosted.org/packages/f4/5f/491dafc7bbf5a3cc1845dc0430872e8096eb9e2b6f8161509d124594ec2d/pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be", size = 3375655 },
+    { url = "https://files.pythonhosted.org/packages/73/d5/c4011a76f4207a3c151134cd22a1415741e42fa5ddecec7c0182887deb3d/pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3", size = 4340304 },
+    { url = "https://files.pythonhosted.org/packages/ac/10/c67e20445a707f7a610699bba4fe050583b688d8cd2d202572b257f46600/pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6", size = 4452804 },
+    { url = "https://files.pythonhosted.org/packages/a9/83/6523837906d1da2b269dee787e31df3b0acb12e3d08f024965a3e7f64665/pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe", size = 4365126 },
+    { url = "https://files.pythonhosted.org/packages/ba/e5/8c68ff608a4203085158cff5cc2a3c534ec384536d9438c405ed6370d080/pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319", size = 4533541 },
+    { url = "https://files.pythonhosted.org/packages/f4/7c/01b8dbdca5bc6785573f4cee96e2358b0918b7b2c7b60d8b6f3abf87a070/pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d", size = 4471616 },
+    { url = "https://files.pythonhosted.org/packages/c8/57/2899b82394a35a0fbfd352e290945440e3b3785655a03365c0ca8279f351/pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696", size = 4600802 },
+    { url = "https://files.pythonhosted.org/packages/4d/d7/a44f193d4c26e58ee5d2d9db3d4854b2cfb5b5e08d360a5e03fe987c0086/pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496", size = 2235213 },
+    { url = "https://files.pythonhosted.org/packages/c1/d0/5866318eec2b801cdb8c82abf190c8343d8a1cd8bf5a0c17444a6f268291/pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91", size = 2554498 },
+    { url = "https://files.pythonhosted.org/packages/d4/c8/310ac16ac2b97e902d9eb438688de0d961660a87703ad1561fd3dfbd2aa0/pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22", size = 2243219 },
+    { url = "https://files.pythonhosted.org/packages/05/cb/0353013dc30c02a8be34eb91d25e4e4cf594b59e5a55ea1128fde1e5f8ea/pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94", size = 3509350 },
+    { url = "https://files.pythonhosted.org/packages/e7/cf/5c558a0f247e0bf9cec92bff9b46ae6474dd736f6d906315e60e4075f737/pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597", size = 3374980 },
+    { url = "https://files.pythonhosted.org/packages/84/48/6e394b86369a4eb68b8a1382c78dc092245af517385c086c5094e3b34428/pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80", size = 4343799 },
+    { url = "https://files.pythonhosted.org/packages/3b/f3/a8c6c11fa84b59b9df0cd5694492da8c039a24cd159f0f6918690105c3be/pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca", size = 4459973 },
+    { url = "https://files.pythonhosted.org/packages/7d/1b/c14b4197b80150fb64453585247e6fb2e1d93761fa0fa9cf63b102fde822/pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef", size = 4370054 },
+    { url = "https://files.pythonhosted.org/packages/55/77/40daddf677897a923d5d33329acd52a2144d54a9644f2a5422c028c6bf2d/pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a", size = 4539484 },
+    { url = "https://files.pythonhosted.org/packages/40/54/90de3e4256b1207300fb2b1d7168dd912a2fb4b2401e439ba23c2b2cabde/pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b", size = 4477375 },
+    { url = "https://files.pythonhosted.org/packages/13/24/1bfba52f44193860918ff7c93d03d95e3f8748ca1de3ceaf11157a14cf16/pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9", size = 4608773 },
+    { url = "https://files.pythonhosted.org/packages/55/04/5e6de6e6120451ec0c24516c41dbaf80cce1b6451f96561235ef2429da2e/pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42", size = 2235690 },
+    { url = "https://files.pythonhosted.org/packages/74/0a/d4ce3c44bca8635bd29a2eab5aa181b654a734a29b263ca8efe013beea98/pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a", size = 2554951 },
+    { url = "https://files.pythonhosted.org/packages/b5/ca/184349ee40f2e92439be9b3502ae6cfc43ac4b50bc4fc6b3de7957563894/pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9", size = 2243427 },
+    { url = "https://files.pythonhosted.org/packages/c3/00/706cebe7c2c12a6318aabe5d354836f54adff7156fd9e1bd6c89f4ba0e98/pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3", size = 3525685 },
+    { url = "https://files.pythonhosted.org/packages/cf/76/f658cbfa49405e5ecbfb9ba42d07074ad9792031267e782d409fd8fe7c69/pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb", size = 3374883 },
+    { url = "https://files.pythonhosted.org/packages/46/2b/99c28c4379a85e65378211971c0b430d9c7234b1ec4d59b2668f6299e011/pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70", size = 4339837 },
+    { url = "https://files.pythonhosted.org/packages/f1/74/b1ec314f624c0c43711fdf0d8076f82d9d802afd58f1d62c2a86878e8615/pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be", size = 4455562 },
+    { url = "https://files.pythonhosted.org/packages/4a/2a/4b04157cb7b9c74372fa867096a1607e6fedad93a44deeff553ccd307868/pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0", size = 4366761 },
+    { url = "https://files.pythonhosted.org/packages/ac/7b/8f1d815c1a6a268fe90481232c98dd0e5fa8c75e341a75f060037bd5ceae/pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc", size = 4536767 },
+    { url = "https://files.pythonhosted.org/packages/e5/77/05fa64d1f45d12c22c314e7b97398ffb28ef2813a485465017b7978b3ce7/pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a", size = 4477989 },
+    { url = "https://files.pythonhosted.org/packages/12/63/b0397cfc2caae05c3fb2f4ed1b4fc4fc878f0243510a7a6034ca59726494/pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309", size = 4610255 },
+    { url = "https://files.pythonhosted.org/packages/7b/f9/cfaa5082ca9bc4a6de66ffe1c12c2d90bf09c309a5f52b27759a596900e7/pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060", size = 2235603 },
+    { url = "https://files.pythonhosted.org/packages/01/6a/30ff0eef6e0c0e71e55ded56a38d4859bf9d3634a94a88743897b5f96936/pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea", size = 2554972 },
+    { url = "https://files.pythonhosted.org/packages/48/2c/2e0a52890f269435eee38b21c8218e102c621fe8d8df8b9dd06fabf879ba/pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d", size = 2243375 },
+    { url = "https://files.pythonhosted.org/packages/56/70/f40009702a477ce87d8d9faaa4de51d6562b3445d7a314accd06e4ffb01d/pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736", size = 3509213 },
+    { url = "https://files.pythonhosted.org/packages/10/43/105823d233c5e5d31cea13428f4474ded9d961652307800979a59d6a4276/pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b", size = 3375883 },
+    { url = "https://files.pythonhosted.org/packages/3c/ad/7850c10bac468a20c918f6a5dbba9ecd106ea1cdc5db3c35e33a60570408/pillow-10.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2", size = 4330810 },
+    { url = "https://files.pythonhosted.org/packages/84/4c/69bbed9e436ac22f9ed193a2b64f64d68fcfbc9f4106249dc7ed4889907b/pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680", size = 4444341 },
+    { url = "https://files.pythonhosted.org/packages/8f/4f/c183c63828a3f37bf09644ce94cbf72d4929b033b109160a5379c2885932/pillow-10.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b", size = 4356005 },
+    { url = "https://files.pythonhosted.org/packages/fb/ad/435fe29865f98a8fbdc64add8875a6e4f8c97749a93577a8919ec6f32c64/pillow-10.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd", size = 4525201 },
+    { url = "https://files.pythonhosted.org/packages/80/74/be8bf8acdfd70e91f905a12ae13cfb2e17c0f1da745c40141e26d0971ff5/pillow-10.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84", size = 4460635 },
+    { url = "https://files.pythonhosted.org/packages/e4/90/763616e66dc9ad59c9b7fb58f863755e7934ef122e52349f62c7742b82d3/pillow-10.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0", size = 4590283 },
+    { url = "https://files.pythonhosted.org/packages/69/66/03002cb5b2c27bb519cba63b9f9aa3709c6f7a5d3b285406c01f03fb77e5/pillow-10.4.0-cp38-cp38-win32.whl", hash = "sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e", size = 2235185 },
+    { url = "https://files.pythonhosted.org/packages/f2/75/3cb820b2812405fc7feb3d0deb701ef0c3de93dc02597115e00704591bc9/pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab", size = 2554594 },
+    { url = "https://files.pythonhosted.org/packages/31/85/955fa5400fa8039921f630372cfe5056eed6e1b8e0430ee4507d7de48832/pillow-10.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d", size = 3509283 },
+    { url = "https://files.pythonhosted.org/packages/23/9c/343827267eb28d41cd82b4180d33b10d868af9077abcec0af9793aa77d2d/pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b", size = 3375691 },
+    { url = "https://files.pythonhosted.org/packages/60/a3/7ebbeabcd341eab722896d1a5b59a3df98c4b4d26cf4b0385f8aa94296f7/pillow-10.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd", size = 4328295 },
+    { url = "https://files.pythonhosted.org/packages/32/3f/c02268d0c6fb6b3958bdda673c17b315c821d97df29ae6969f20fb49388a/pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126", size = 4440810 },
+    { url = "https://files.pythonhosted.org/packages/67/5d/1c93c8cc35f2fdd3d6cc7e4ad72d203902859a2867de6ad957d9b708eb8d/pillow-10.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b", size = 4352283 },
+    { url = "https://files.pythonhosted.org/packages/bc/a8/8655557c9c7202b8abbd001f61ff36711cefaf750debcaa1c24d154ef602/pillow-10.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c", size = 4521800 },
+    { url = "https://files.pythonhosted.org/packages/58/78/6f95797af64d137124f68af1bdaa13b5332da282b86031f6fa70cf368261/pillow-10.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1", size = 4459177 },
+    { url = "https://files.pythonhosted.org/packages/8a/6d/2b3ce34f1c4266d79a78c9a51d1289a33c3c02833fe294ef0dcbb9cba4ed/pillow-10.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df", size = 4589079 },
+    { url = "https://files.pythonhosted.org/packages/e3/e0/456258c74da1ff5bf8ef1eab06a95ca994d8b9ed44c01d45c3f8cbd1db7e/pillow-10.4.0-cp39-cp39-win32.whl", hash = "sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef", size = 2235247 },
+    { url = "https://files.pythonhosted.org/packages/37/f8/bef952bdb32aa53741f58bf21798642209e994edc3f6598f337f23d5400a/pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5", size = 2554479 },
+    { url = "https://files.pythonhosted.org/packages/bb/8e/805201619cad6651eef5fc1fdef913804baf00053461522fabbc5588ea12/pillow-10.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e", size = 2243226 },
+    { url = "https://files.pythonhosted.org/packages/38/30/095d4f55f3a053392f75e2eae45eba3228452783bab3d9a920b951ac495c/pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4", size = 3493889 },
+    { url = "https://files.pythonhosted.org/packages/f3/e8/4ff79788803a5fcd5dc35efdc9386af153569853767bff74540725b45863/pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da", size = 3346160 },
+    { url = "https://files.pythonhosted.org/packages/d7/ac/4184edd511b14f760c73f5bb8a5d6fd85c591c8aff7c2229677a355c4179/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026", size = 3435020 },
+    { url = "https://files.pythonhosted.org/packages/da/21/1749cd09160149c0a246a81d646e05f35041619ce76f6493d6a96e8d1103/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e", size = 3490539 },
+    { url = "https://files.pythonhosted.org/packages/b6/f5/f71fe1888b96083b3f6dfa0709101f61fc9e972c0c8d04e9d93ccef2a045/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5", size = 3476125 },
+    { url = "https://files.pythonhosted.org/packages/96/b9/c0362c54290a31866c3526848583a2f45a535aa9d725fd31e25d318c805f/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885", size = 3579373 },
+    { url = "https://files.pythonhosted.org/packages/52/3b/ce7a01026a7cf46e5452afa86f97a5e88ca97f562cafa76570178ab56d8d/pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5", size = 2554661 },
+    { url = "https://files.pythonhosted.org/packages/e1/1f/5a9fcd6ced51633c22481417e11b1b47d723f64fb536dfd67c015eb7f0ab/pillow-10.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b", size = 3493850 },
+    { url = "https://files.pythonhosted.org/packages/cb/e6/3ea4755ed5320cb62aa6be2f6de47b058c6550f752dd050e86f694c59798/pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908", size = 3346118 },
+    { url = "https://files.pythonhosted.org/packages/0a/22/492f9f61e4648422b6ca39268ec8139277a5b34648d28f400faac14e0f48/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b", size = 3434958 },
+    { url = "https://files.pythonhosted.org/packages/f9/19/559a48ad4045704bb0547965b9a9345f5cd461347d977a56d178db28819e/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8", size = 3490340 },
+    { url = "https://files.pythonhosted.org/packages/d9/de/cebaca6fb79905b3a1aa0281d238769df3fb2ede34fd7c0caa286575915a/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a", size = 3476048 },
+    { url = "https://files.pythonhosted.org/packages/71/f0/86d5b2f04693b0116a01d75302b0a307800a90d6c351a8aa4f8ae76cd499/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27", size = 3579366 },
+    { url = "https://files.pythonhosted.org/packages/37/ae/2dbfc38cc4fd14aceea14bc440d5151b21f64c4c3ba3f6f4191610b7ee5d/pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3", size = 2554652 },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
+]
+
+[[package]]
+name = "py"
+version = "1.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/ff/fec109ceb715d2a6b4c4a85a61af3b40c723a961e8828319fbcb15b868dc/py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719", size = 207796 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f6/f0/10642828a8dfb741e5f3fbaac830550a518a775c7fff6f04a007259b0548/py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378", size = 98708 },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.10.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/78/58c36d0cf331b659d0ccd99175e3523c457b4f8e67cb92a8fdc22ec1667c/pydantic-2.10.0.tar.gz", hash = "sha256:0aca0f045ff6e2f097f1fe89521115335f15049eeb8a7bef3dafe4b19a74e289", size = 781980 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/ee/255cbfdbf5c47650de70ac8a5425107511f505ed0366c29d537f7f1842e1/pydantic-2.10.0-py3-none-any.whl", hash = "sha256:5e7807ba9201bdf61b1b58aa6eb690916c40a47acfb114b1b4fef3e7fd5b30fc", size = 454346 },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.27.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/cd/8331ae216bcc5a3f2d4c6b941c9f63de647e2700d38133f4f7e0132a00c4/pydantic_core-2.27.0.tar.gz", hash = "sha256:f57783fbaf648205ac50ae7d646f27582fc706be3977e87c3c124e7a92407b10", size = 412675 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/97/8a42e9c17c305516c0d956a2887d616d3a1b0531b0053ac95a917e4a1ab7/pydantic_core-2.27.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:cd2ac6b919f7fed71b17fe0b4603c092a4c9b5bae414817c9c81d3c22d1e1bcc", size = 1893954 },
+    { url = "https://files.pythonhosted.org/packages/5b/09/ff3ce866f769ebbae2abdcd742247dc2bd6967d646daf54a562ceee6abdb/pydantic_core-2.27.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e015833384ca3e1a0565a79f5d953b0629d9138021c27ad37c92a9fa1af7623c", size = 1807944 },
+    { url = "https://files.pythonhosted.org/packages/88/d7/e04d06ca71a0bd7f4cac24e6aa562129969c91117e5fad2520ede865c8cb/pydantic_core-2.27.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:db72e40628967f6dc572020d04b5f800d71264e0531c6da35097e73bdf38b003", size = 1829151 },
+    { url = "https://files.pythonhosted.org/packages/14/24/90b0babb61b68ecc471ce5becad8f7fc5f7835c601774e5de577b051b7ad/pydantic_core-2.27.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:df45c4073bed486ea2f18757057953afed8dd77add7276ff01bccb79982cf46c", size = 1849502 },
+    { url = "https://files.pythonhosted.org/packages/fc/34/62612e655b4d693a6ec515fd0ddab4bfc0cc6759076e09c23fc6966bd07b/pydantic_core-2.27.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:836a4bfe0cc6d36dc9a9cc1a7b391265bf6ce9d1eb1eac62ac5139f5d8d9a6fa", size = 2035489 },
+    { url = "https://files.pythonhosted.org/packages/12/7d/0ff62235adda41b87c495c1b95c84d4debfecb91cfd62e3100abad9754fa/pydantic_core-2.27.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4bf1340ae507f6da6360b24179c2083857c8ca7644aab65807023cf35404ea8d", size = 2774949 },
+    { url = "https://files.pythonhosted.org/packages/7f/ac/e1867e2b808a668f32ad9012eaeac0b0ee377eee8157ab93720f48ee609b/pydantic_core-2.27.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ab325fc86fbc077284c8d7f996d904d30e97904a87d6fb303dce6b3de7ebba9", size = 2130123 },
+    { url = "https://files.pythonhosted.org/packages/2f/04/5006f2dbf655052826ac8d03d51b9a122de709fed76eb1040aa21772f530/pydantic_core-2.27.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1da0c98a85a6c6ed702d5556db3b09c91f9b0b78de37b7593e2de8d03238807a", size = 1981988 },
+    { url = "https://files.pythonhosted.org/packages/80/8b/bdbe875c4758282402e3cc75fa6bf2f0c8ffac1874f384190034786d3cbc/pydantic_core-2.27.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7b0202ebf2268954090209a84f9897345719e46a57c5f2c9b7b250ca0a9d3e63", size = 1992043 },
+    { url = "https://files.pythonhosted.org/packages/2f/2d/4e46981cfcf4ca4c2ff7734dec08162e398dc598c6c0687454b05a82dc2f/pydantic_core-2.27.0-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:35380671c3c921fe8adf31ad349dc6f7588b7e928dbe44e1093789734f607399", size = 2087309 },
+    { url = "https://files.pythonhosted.org/packages/d2/43/56ef2e72360d909629a54198d2bc7ef60f19fde8ceb5c90d7749120d0b61/pydantic_core-2.27.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b4c19525c3538fbc0bbda6229f9682fb8199ce9ac37395880e6952798e00373", size = 2140517 },
+    { url = "https://files.pythonhosted.org/packages/61/40/81e5d8f84ab070cf091d072bb61b6021ff79d7110b2d0145fe3171b6107b/pydantic_core-2.27.0-cp310-none-win32.whl", hash = "sha256:333c840a1303d1474f491e7be0b718226c730a39ead0f7dab2c7e6a2f3855555", size = 1814120 },
+    { url = "https://files.pythonhosted.org/packages/05/64/e543d342b991d38426bcb841bc0b4b95b9bd2191367ba0cc75f258e3d583/pydantic_core-2.27.0-cp310-none-win_amd64.whl", hash = "sha256:99b2863c1365f43f74199c980a3d40f18a218fbe683dd64e470199db426c4d6a", size = 1972268 },
+    { url = "https://files.pythonhosted.org/packages/85/ba/5ed9583a44d9fbd6fbc028df8e3eae574a3ef4761d7f56bb4e0eb428d5ce/pydantic_core-2.27.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4523c4009c3f39d948e01962223c9f5538602e7087a628479b723c939fab262d", size = 1891468 },
+    { url = "https://files.pythonhosted.org/packages/50/1e/58baa0fde14aafccfcc09a8b45bdc11eb941b58a69536729d832e383bdbd/pydantic_core-2.27.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:84af1cf7bfdcbc6fcf5a5f70cc9896205e0350306e4dd73d54b6a18894f79386", size = 1807103 },
+    { url = "https://files.pythonhosted.org/packages/7d/87/0422a653ddfcf68763eb56d6e4e2ad19df6d5e006f3f4b854fda06ce2ba3/pydantic_core-2.27.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e65466b31be1070b4a5b7dbfbd14b247884cb8e8b79c64fb0f36b472912dbaea", size = 1827446 },
+    { url = "https://files.pythonhosted.org/packages/a4/48/8e431b7732695c93ded79214299a83ac04249d748243b8ba6644ab076574/pydantic_core-2.27.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a5c022bb0d453192426221605efc865373dde43b17822a264671c53b068ac20c", size = 1847798 },
+    { url = "https://files.pythonhosted.org/packages/98/7d/e1f28e12a26035d7c8b7678830400e5b94129c9ccb74636235a2eeeee40f/pydantic_core-2.27.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6bb69bf3b6500f195c3deb69c1205ba8fc3cb21d1915f1f158a10d6b1ef29b6a", size = 2033797 },
+    { url = "https://files.pythonhosted.org/packages/89/b4/ad5bc2b43b7ca8fd5f5068eca7f195565f53911d9ae69925f7f21859a929/pydantic_core-2.27.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0aa4d1b2eba9a325897308b3124014a142cdccb9f3e016f31d3ebee6b5ea5e75", size = 2767592 },
+    { url = "https://files.pythonhosted.org/packages/3e/a6/7fb0725eaf1122518c018bfe38aaf4ad3d512e8598e2c08419b9a270f4bf/pydantic_core-2.27.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e96ca781e0c01e32115912ebdf7b3fb0780ce748b80d7d28a0802fa9fbaf44e", size = 2130244 },
+    { url = "https://files.pythonhosted.org/packages/a1/2c/453e52a866947a153bb575bbbb6b14db344f07a73b2ad820ff8f40e9807b/pydantic_core-2.27.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b872c86d8d71827235c7077461c502feb2db3f87d9d6d5a9daa64287d75e4fa0", size = 1979626 },
+    { url = "https://files.pythonhosted.org/packages/7a/43/1faa8601085dab2a37dfaca8d48605b76e38aeefcde58bf95534ab96b135/pydantic_core-2.27.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:82e1ad4ca170e8af4c928b67cff731b6296e6a0a0981b97b2eb7c275cc4e15bd", size = 1990741 },
+    { url = "https://files.pythonhosted.org/packages/dd/ef/21f25f5964979b7e6f9102074083b5448c22c871da438d91db09601e6634/pydantic_core-2.27.0-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:eb40f828bc2f73f777d1eb8fee2e86cd9692a4518b63b6b5aa8af915dfd3207b", size = 2086325 },
+    { url = "https://files.pythonhosted.org/packages/8a/f9/81e5f910571a20655dd7bf10e6d6db8c279e250bfbdb5ab1a09ce3e0eb82/pydantic_core-2.27.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9a8fbf506fde1529a1e3698198fe64bfbe2e0c09557bc6a7dcf872e7c01fec40", size = 2138839 },
+    { url = "https://files.pythonhosted.org/packages/59/c4/27917b73d0631098b91f2ec303e1becb823fead0628ee9055fca78ec1e2e/pydantic_core-2.27.0-cp311-none-win32.whl", hash = "sha256:24f984fc7762ed5f806d9e8c4c77ea69fdb2afd987b4fd319ef06c87595a8c55", size = 1809514 },
+    { url = "https://files.pythonhosted.org/packages/ea/48/a30c67d62b8f39095edc3dab6abe69225e8c57186f31cc59a1ab984ea8e6/pydantic_core-2.27.0-cp311-none-win_amd64.whl", hash = "sha256:68950bc08f9735306322bfc16a18391fcaac99ded2509e1cc41d03ccb6013cfe", size = 1971838 },
+    { url = "https://files.pythonhosted.org/packages/4e/9e/3798b901cf331058bae0ba4712a52fb0106c39f913830aaf71f01fd10d45/pydantic_core-2.27.0-cp311-none-win_arm64.whl", hash = "sha256:3eb8849445c26b41c5a474061032c53e14fe92a11a5db969f722a2716cd12206", size = 1862174 },
+    { url = "https://files.pythonhosted.org/packages/82/99/43149b127559f3152cd28cb7146592c6547cfe47d528761954e2e8fcabaf/pydantic_core-2.27.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8117839a9bdbba86e7f9df57018fe3b96cec934c3940b591b0fd3fbfb485864a", size = 1887064 },
+    { url = "https://files.pythonhosted.org/packages/7e/dd/989570c76334aa55ccb4ee8b5e0e6881a513620c6172d93b2f3b77e10f81/pydantic_core-2.27.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a291d0b4243a259c8ea7e2b84eb9ccb76370e569298875a7c5e3e71baf49057a", size = 1804405 },
+    { url = "https://files.pythonhosted.org/packages/3e/b5/bce1d6d6fb71d916c74bf988b7d0cd7fc0c23da5e08bc0d6d6e08c12bf36/pydantic_core-2.27.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84e35afd9e10b2698e6f2f32256678cb23ca6c1568d02628033a837638b3ed12", size = 1822595 },
+    { url = "https://files.pythonhosted.org/packages/35/93/a6e5e04625ac8fcbed523d7b741e91cc3a37ed1e04e16f8f2f34269bbe53/pydantic_core-2.27.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:58ab0d979c969983cdb97374698d847a4acffb217d543e172838864636ef10d9", size = 1848701 },
+    { url = "https://files.pythonhosted.org/packages/3a/74/56ead1436e3f6513b59b3a442272578a6ec09a39ab95abd5ee321bcc8c95/pydantic_core-2.27.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0d06b667e53320332be2bf6f9461f4a9b78092a079b8ce8634c9afaa7e10cd9f", size = 2031878 },
+    { url = "https://files.pythonhosted.org/packages/e1/4d/8905b2710ef653c0da27224bfb6a084b5873ad6fdb975dda837943e5639d/pydantic_core-2.27.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78f841523729e43e3928a364ec46e2e3f80e6625a4f62aca5c345f3f626c6e8a", size = 2673386 },
+    { url = "https://files.pythonhosted.org/packages/1d/f0/abe1511f11756d12ce18d016f3555cb47211590e4849ee02e7adfdd1684e/pydantic_core-2.27.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:400bf470e4327e920883b51e255617dfe4496d4e80c3fea0b5a5d0bf2c404dd4", size = 2152867 },
+    { url = "https://files.pythonhosted.org/packages/c7/90/1c588d4d93ce53e1f5ab0cea2d76151fcd36613446bf99b670d7da9ddf89/pydantic_core-2.27.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:951e71da6c89d354572098bada5ba5b5dc3a9390c933af8a614e37755d3d1840", size = 1986595 },
+    { url = "https://files.pythonhosted.org/packages/a3/9c/27d06369f39375966836cde5c8aec0a66dc2f532c13d9aa1a6c370131fbd/pydantic_core-2.27.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2a51ce96224eadd1845150b204389623c8e129fde5a67a84b972bd83a85c6c40", size = 1995731 },
+    { url = "https://files.pythonhosted.org/packages/26/4e/b039e52b7f4c51d9fae6715d5d2e47a57c369b8e0cb75838974a193aae40/pydantic_core-2.27.0-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:483c2213a609e7db2c592bbc015da58b6c75af7360ca3c981f178110d9787bcf", size = 2085771 },
+    { url = "https://files.pythonhosted.org/packages/01/93/2796bd116a93e7e4e10baca4c55266c4d214b3b4e5ee7f0e9add69c184af/pydantic_core-2.27.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:359e7951f04ad35111b5ddce184db3391442345d0ab073aa63a95eb8af25a5ef", size = 2150452 },
+    { url = "https://files.pythonhosted.org/packages/0f/93/e57562d6ea961557174c3afa481a73ce0e2d8b823e0eb2b320bfb00debbe/pydantic_core-2.27.0-cp312-none-win32.whl", hash = "sha256:ee7d9d5537daf6d5c74a83b38a638cc001b648096c1cae8ef695b0c919d9d379", size = 1830767 },
+    { url = "https://files.pythonhosted.org/packages/44/00/4f121ca5dd06420813e7858395b5832603ed0074a5b74ef3104c8dbc2fd5/pydantic_core-2.27.0-cp312-none-win_amd64.whl", hash = "sha256:2be0ad541bb9f059954ccf8877a49ed73877f862529575ff3d54bf4223e4dd61", size = 1973909 },
+    { url = "https://files.pythonhosted.org/packages/c3/c7/36f87c0dabbde9c0dd59b9024e4bf117a5122515c864ddbe685ed8301670/pydantic_core-2.27.0-cp312-none-win_arm64.whl", hash = "sha256:6e19401742ed7b69e51d8e4df3c03ad5ec65a83b36244479fd70edde2828a5d9", size = 1877037 },
+    { url = "https://files.pythonhosted.org/packages/9d/b2/740159bdfe532d856e340510246aa1fd723b97cadf1a38153bdfb52efa28/pydantic_core-2.27.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5f2b19b8d6fca432cb3acf48cf5243a7bf512988029b6e6fd27e9e8c0a204d85", size = 1886935 },
+    { url = "https://files.pythonhosted.org/packages/ca/2a/2f435d9fd591c912ca227f29c652a93775d35d54677b57c3157bbad823b5/pydantic_core-2.27.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c86679f443e7085ea55a7376462553996c688395d18ef3f0d3dbad7838f857a2", size = 1805318 },
+    { url = "https://files.pythonhosted.org/packages/ba/f2/755b628009530b19464bb95c60f829b47a6ef7930f8ca1d87dac90fd2848/pydantic_core-2.27.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:510b11e9c3b1a852876d1ccd8d5903684336d635214148637ceb27366c75a467", size = 1822284 },
+    { url = "https://files.pythonhosted.org/packages/3d/c2/a12744628b1b55c5384bd77657afa0780868484a92c37a189fb460d1cfe7/pydantic_core-2.27.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb704155e73b833801c247f39d562229c0303f54770ca14fb1c053acb376cf10", size = 1848522 },
+    { url = "https://files.pythonhosted.org/packages/60/1d/dfcb8ab94a4637d4cf682550a2bf94695863988e7bcbd6f4d83c04178e17/pydantic_core-2.27.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9ce048deb1e033e7a865ca384770bccc11d44179cf09e5193a535c4c2f497bdc", size = 2031678 },
+    { url = "https://files.pythonhosted.org/packages/ee/c8/f9cbcab0275e031c4312223c75d999b61fba60995003cd89dc4866300059/pydantic_core-2.27.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:58560828ee0951bb125c6f2862fbc37f039996d19ceb6d8ff1905abf7da0bf3d", size = 2672948 },
+    { url = "https://files.pythonhosted.org/packages/41/f9/c613546237cf58ed7a7fa9158410c14d0e7e0cbbf95f83a905c9424bb074/pydantic_core-2.27.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:abb4785894936d7682635726613c44578c420a096729f1978cd061a7e72d5275", size = 2152419 },
+    { url = "https://files.pythonhosted.org/packages/49/71/b951b03a271678b1d1b79481dac38cf8bce8a4e178f36ada0e9aff65a679/pydantic_core-2.27.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2883b260f7a93235488699d39cbbd94fa7b175d3a8063fbfddd3e81ad9988cb2", size = 1986408 },
+    { url = "https://files.pythonhosted.org/packages/9a/2c/07b0d5b5e1cdaa07b7c23e758354377d294ff0395116d39c9fa734e5d89e/pydantic_core-2.27.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c6fcb3fa3855d583aa57b94cf146f7781d5d5bc06cb95cb3afece33d31aac39b", size = 1995895 },
+    { url = "https://files.pythonhosted.org/packages/63/09/c21e0d7438c7e742209cc8603607c8d389df96018396c8a2577f6e24c5c5/pydantic_core-2.27.0-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:e851a051f7260e6d688267eb039c81f05f23a19431bd7dfa4bf5e3cb34c108cd", size = 2085914 },
+    { url = "https://files.pythonhosted.org/packages/68/e4/5ed8f09d92655dcd0a86ee547e509adb3e396cef0a48f5c31e3b060bb9d0/pydantic_core-2.27.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:edb1bfd45227dec8d50bc7c7d86463cd8728bcc574f9b07de7369880de4626a3", size = 2150217 },
+    { url = "https://files.pythonhosted.org/packages/cd/e6/a202f0e1b81c729130404e82d9de90dc4418ec01df35000d48d027c38501/pydantic_core-2.27.0-cp313-none-win32.whl", hash = "sha256:678f66462058dd978702db17eb6a3633d634f7aa0deaea61e0a674152766d3fc", size = 1830973 },
+    { url = "https://files.pythonhosted.org/packages/06/3d/21ed0f308e6618ce6c5c6bfb9e71734a9a3256d5474a53c8e5aaaba498ca/pydantic_core-2.27.0-cp313-none-win_amd64.whl", hash = "sha256:d28ca7066d6cdd347a50d8b725dc10d9a1d6a1cce09836cf071ea6a2d4908be0", size = 1974853 },
+    { url = "https://files.pythonhosted.org/packages/d7/18/e5744a132b81f98b9f92e15f33f03229a1d254ce7af942b1422ec2ac656f/pydantic_core-2.27.0-cp313-none-win_arm64.whl", hash = "sha256:6f4a53af9e81d757756508b57cae1cf28293f0f31b9fa2bfcb416cc7fb230f9d", size = 1877469 },
+    { url = "https://files.pythonhosted.org/packages/e1/79/9ff7da9e775aa9bf42c9df93fc940d421216b22d255a6edbc11aa291d3f0/pydantic_core-2.27.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:e9f9feee7f334b72ceae46313333d002b56f325b5f04271b4ae2aadd9e993ae4", size = 1897587 },
+    { url = "https://files.pythonhosted.org/packages/5d/62/fecc64300ea766b6b45de87663ff2adba63c6624a71ba8bc5a323e17ef5e/pydantic_core-2.27.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:225bfff5d425c34e1fd562cef52d673579d59b967d9de06178850c4802af9039", size = 1777716 },
+    { url = "https://files.pythonhosted.org/packages/89/96/85e7daa1151104c24f4b007d32374c899c5e66ebbbf4da4debd1794e084f/pydantic_core-2.27.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c921ad596ff1a82f9c692b0758c944355abc9f0de97a4c13ca60ffc6d8dc15d4", size = 1831004 },
+    { url = "https://files.pythonhosted.org/packages/80/31/a9c66908c95dd2a04d84baa98b46d8ea35abb13354d0a27ac47ffab6decf/pydantic_core-2.27.0-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6354e18a9be37bfa124d6b288a87fb30c673745806c92956f1a25e3ae6e76b96", size = 1850721 },
+    { url = "https://files.pythonhosted.org/packages/48/a4/7bc31d7bc5dcbc6d7c8ab2ada38a99d2bd22e93b73e9a9a2a84626016740/pydantic_core-2.27.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8ee4c2a75af9fe21269a4a0898c5425afb01af1f5d276063f57e2ae1bc64e191", size = 2037703 },
+    { url = "https://files.pythonhosted.org/packages/5c/d8/8f68ab9d67c129dc046ad1aa105dc3a86c9ffb6c2243d44d7140381007ea/pydantic_core-2.27.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c91e3c04f5191fd3fb68764bddeaf02025492d5d9f23343b283870f6ace69708", size = 2771401 },
+    { url = "https://files.pythonhosted.org/packages/8e/e1/bb637cf80583bf9058b8e5a7645cdc99a8adf3941a58329ced63f4c63843/pydantic_core-2.27.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a6ebfac28fd51890a61df36ef202adbd77d00ee5aca4a3dadb3d9ed49cfb929", size = 2133159 },
+    { url = "https://files.pythonhosted.org/packages/50/82/c9b7dc0b081a3f26ee321f56b67e5725ec94128d92f1e08525080ba2f2df/pydantic_core-2.27.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:36aa167f69d8807ba7e341d67ea93e50fcaaf6bc433bb04939430fa3dab06f31", size = 1983746 },
+    { url = "https://files.pythonhosted.org/packages/65/02/6b308344a5968a1b99959fb965e72525837f609adf2412d47769902b2db5/pydantic_core-2.27.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:3e8d89c276234579cd3d095d5fa2a44eb10db9a218664a17b56363cddf226ff3", size = 1992306 },
+    { url = "https://files.pythonhosted.org/packages/f2/d6/4f9c7059020863535810a027f993bb384da1f9af60b4d6364493661befb6/pydantic_core-2.27.0-cp38-cp38-musllinux_1_1_armv7l.whl", hash = "sha256:5cc822ab90a70ea3a91e6aed3afac570b276b1278c6909b1d384f745bd09c714", size = 2088195 },
+    { url = "https://files.pythonhosted.org/packages/80/1e/896a1472a6d7863144e0738181cfdad872c90b57d5c1a5ee073838d751c5/pydantic_core-2.27.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e15315691fe2253eb447503153acef4d7223dfe7e7702f9ed66539fcd0c43801", size = 2142683 },
+    { url = "https://files.pythonhosted.org/packages/8b/fe/773312dae0be37017e91e2684834bc971aca8f8b6f44e5395c7e4814ae52/pydantic_core-2.27.0-cp38-none-win32.whl", hash = "sha256:dfa5f5c0a4c8fced1422dc2ca7eefd872d5d13eb33cf324361dbf1dbfba0a9fe", size = 1817110 },
+    { url = "https://files.pythonhosted.org/packages/90/c1/219e5b3c4dd33d88dee17479b5a3aace3c9c66f26cb7317acc33d74ef02a/pydantic_core-2.27.0-cp38-none-win_amd64.whl", hash = "sha256:513cb14c0cc31a4dfd849a4674b20c46d87b364f997bbcb02282306f5e187abf", size = 1970874 },
+    { url = "https://files.pythonhosted.org/packages/00/e4/4d6d9193a33c964920bf56fcbe11fa30511d3d900a81c740b0157579b122/pydantic_core-2.27.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:4148dc9184ab79e356dc00a4199dc0ee8647973332cb385fc29a7cced49b9f9c", size = 1894360 },
+    { url = "https://files.pythonhosted.org/packages/f4/46/9d27771309609126678dee81e8e93188dbd0515a543b27e0a01a806c1893/pydantic_core-2.27.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5fc72fbfebbf42c0856a824b8b0dc2b5cd2e4a896050281a21cfa6fed8879cb1", size = 1773921 },
+    { url = "https://files.pythonhosted.org/packages/a0/3a/3a6a4cee7bc11bcb3f8859a63c6b4d88b8df66ad7c9c9e6d667dd894b439/pydantic_core-2.27.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:185ef205256cd8b38431205698531026979db89a79587725c1e55c59101d64e9", size = 1829480 },
+    { url = "https://files.pythonhosted.org/packages/2b/aa/ecf0fcee9031eef516cef2e336d403a61bd8df75ab17a856bc29f3eb07d4/pydantic_core-2.27.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:395e3e1148fa7809016231f8065f30bb0dc285a97b4dc4360cd86e17bab58af7", size = 1849759 },
+    { url = "https://files.pythonhosted.org/packages/b6/17/8953bbbe7d3c015bdfa34171ba1738a43682d770e68c87171dd8887035c3/pydantic_core-2.27.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:33d14369739c5d07e2e7102cdb0081a1fa46ed03215e07f097b34e020b83b1ae", size = 2035679 },
+    { url = "https://files.pythonhosted.org/packages/ec/19/514fdf2f684003961b6f34543f0bdf3be2e0f17b8b25cd8d44c343521148/pydantic_core-2.27.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e7820bb0d65e3ce1e3e70b6708c2f66143f55912fa02f4b618d0f08b61575f12", size = 2773208 },
+    { url = "https://files.pythonhosted.org/packages/9a/37/2cdd48b7367fbf0576d16402837212d2b1798aa4ea887f1795f8ddbace07/pydantic_core-2.27.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:43b61989068de9ce62296cde02beffabcadb65672207fc51e7af76dca75e6636", size = 2130616 },
+    { url = "https://files.pythonhosted.org/packages/3a/6c/fa100356e1c8f749797d88401a1d5ed8d458705d43e259931681b5b96ab4/pydantic_core-2.27.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:15e350efb67b855cd014c218716feea4986a149ed1f42a539edd271ee074a196", size = 1981857 },
+    { url = "https://files.pythonhosted.org/packages/0f/3d/36c0c832c1fd1351c495bf1495b61b2e40248c54f7874e6df439e6ffb9a5/pydantic_core-2.27.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:433689845288f9a1ee5714444e65957be26d30915f7745091ede4a83cfb2d7bb", size = 1992515 },
+    { url = "https://files.pythonhosted.org/packages/99/12/ee67e29369b368c404c6aead492e1528ec887609d388a7a30b675b969b82/pydantic_core-2.27.0-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:3fd8bc2690e7c39eecdf9071b6a889ce7b22b72073863940edc2a0a23750ca90", size = 2087604 },
+    { url = "https://files.pythonhosted.org/packages/0e/6c/72ca869aabe190e4cd36b03226286e430a1076c367097c77cb0704b1cbb3/pydantic_core-2.27.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:884f1806609c2c66564082540cffc96868c5571c7c3cf3a783f63f2fb49bd3cd", size = 2141000 },
+    { url = "https://files.pythonhosted.org/packages/5c/b8/e7499cfa6f1e46e92a645e74198b7bb9ce3d49e82f626a02726dc917fc74/pydantic_core-2.27.0-cp39-none-win32.whl", hash = "sha256:bf37b72834e7239cf84d4a0b2c050e7f9e48bced97bad9bdf98d26b8eb72e846", size = 1813857 },
+    { url = "https://files.pythonhosted.org/packages/2e/27/81203aa6cbf68772afd9c3877ce2e35878f434e824aad4047e7cfd3bc14d/pydantic_core-2.27.0-cp39-none-win_amd64.whl", hash = "sha256:31a2cae5f059329f9cfe3d8d266d3da1543b60b60130d186d9b6a3c20a346361", size = 1974744 },
+    { url = "https://files.pythonhosted.org/packages/d3/ad/c1dc814ab524cb247ceb6cb25236895a5cae996c438baf504db610fd6c92/pydantic_core-2.27.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4fb49cfdb53af5041aba909be00cccfb2c0d0a2e09281bf542371c5fd36ad04c", size = 1889233 },
+    { url = "https://files.pythonhosted.org/packages/24/bb/069a9dd910e6c09aab90a118c08d3cb30dc5738550e9f2d21f3b086352c2/pydantic_core-2.27.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:49633583eb7dc5cba61aaf7cdb2e9e662323ad394e543ee77af265736bcd3eaa", size = 1768419 },
+    { url = "https://files.pythonhosted.org/packages/cb/a1/f9b4e625ee8c7f683c8295c85d11f79a538eb53719f326646112a7800bda/pydantic_core-2.27.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:153017e3d6cd3ce979de06d84343ca424bb6092727375eba1968c8b4693c6ecb", size = 1822870 },
+    { url = "https://files.pythonhosted.org/packages/12/07/04abaeeabf212650de3edc300b2ab89fb17da9bc4408ef4e01a62efc87dc/pydantic_core-2.27.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff63a92f6e249514ef35bc795de10745be0226eaea06eb48b4bbeaa0c8850a4a", size = 1977039 },
+    { url = "https://files.pythonhosted.org/packages/0f/9d/99bbeb21d5be1d5affdc171e0e84603a757056f9f4293ef236e41af0a5bc/pydantic_core-2.27.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5982048129f40b082c2654de10c0f37c67a14f5ff9d37cf35be028ae982f26df", size = 1974317 },
+    { url = "https://files.pythonhosted.org/packages/5f/78/815aa74db1591a9ad4086bc1bf98e2126686245a956d76cd4e72bf9841ad/pydantic_core-2.27.0-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:91bc66f878557313c2a6bcf396e7befcffe5ab4354cfe4427318968af31143c3", size = 1985101 },
+    { url = "https://files.pythonhosted.org/packages/d9/a8/9c1557d5282108916448415e85f829b70ba99d97f03cee0e40a296e58a65/pydantic_core-2.27.0-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:68ef5377eb582fa4343c9d0b57a5b094046d447b4c73dd9fbd9ffb216f829e7d", size = 2073399 },
+    { url = "https://files.pythonhosted.org/packages/ca/b0/5296273d652fa9aa140771b3f4bb574edd3cbf397090625b988f6a57b02b/pydantic_core-2.27.0-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:c5726eec789ee38f2c53b10b1821457b82274f81f4f746bb1e666d8741fcfadb", size = 2129499 },
+    { url = "https://files.pythonhosted.org/packages/e9/fd/7f39ff702fdca954f26c84b40d9bf744733bb1a50ca6b7569822b9cbb7f4/pydantic_core-2.27.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c0c431e4be5c1a0c6654e0c31c661cd89e0ca956ef65305c3c3fd96f4e72ca39", size = 1997246 },
+    { url = "https://files.pythonhosted.org/packages/bb/4f/76f1ac16a0c277a3a8be2b5b52b0a09929630e794fb1938c4cd85396c34f/pydantic_core-2.27.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:8e21d927469d04b39386255bf00d0feedead16f6253dcc85e9e10ddebc334084", size = 1889486 },
+    { url = "https://files.pythonhosted.org/packages/f3/96/4ff5a8ec0c457afcd87334d4e2f6fd25df6642b4ff8bf587316dd6eccd59/pydantic_core-2.27.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:4b51f964fcbb02949fc546022e56cdb16cda457af485e9a3e8b78ac2ecf5d77e", size = 1768718 },
+    { url = "https://files.pythonhosted.org/packages/52/21/e7bab7b9674d5b1a8cf06939929991753e4b814b01bae29321a8739990b3/pydantic_core-2.27.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25a7fd4de38f7ff99a37e18fa0098c3140286451bc823d1746ba80cec5b433a1", size = 1823291 },
+    { url = "https://files.pythonhosted.org/packages/1d/68/d1868a78ce0d776c3e04179fbfa6272e72d4363c49f9bdecfe4b2007dd75/pydantic_core-2.27.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fda87808429c520a002a85d6e7cdadbf58231d60e96260976c5b8f9a12a8e13", size = 1977040 },
+    { url = "https://files.pythonhosted.org/packages/68/7b/2e361ff81f60c4c28f65b53670436849ec716366d4f1635ea243a31903a2/pydantic_core-2.27.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8a150392102c402c538190730fda06f3bce654fc498865579a9f2c1d2b425833", size = 1973909 },
+    { url = "https://files.pythonhosted.org/packages/a8/44/a4a3718f3b148526baccdb9a0bc8e6b7aa840c796e637805c04aaf1a74c3/pydantic_core-2.27.0-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c9ed88b398ba7e3bad7bd64d66cc01dcde9cfcb7ec629a6fd78a82fa0b559d78", size = 1985091 },
+    { url = "https://files.pythonhosted.org/packages/3a/79/2cdf503e8aac926a99d64b2a02642ab1377146999f9a68536c54bd8b2c46/pydantic_core-2.27.0-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:9fe94d9d2a2b4edd7a4b22adcd45814b1b59b03feb00e56deb2e89747aec7bfe", size = 2073484 },
+    { url = "https://files.pythonhosted.org/packages/e8/15/74c61b7ea348b252fe97a32e5b531fdde331710db80e9b0fae1302023414/pydantic_core-2.27.0-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:d8b5ee4ae9170e2775d495b81f414cc20268041c42571530513496ba61e94ba3", size = 2129473 },
+    { url = "https://files.pythonhosted.org/packages/57/81/0e9ebcc80b107e1dfacc677ad7c2ab0202cc0e10ba76b23afbb147ac32fb/pydantic_core-2.27.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:d29e235ce13c91902ef3efc3d883a677655b3908b1cbc73dee816e5e1f8f7739", size = 1997389 },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/08/13f3bce01b2061f2bbd582c9df82723de943784cf719a35ac886c652043a/pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032", size = 900231 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/0c/0e3c05b1c87bb6a1c76d281b0f35e78d2d80ac91b5f8f524cebf77f51049/pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c", size = 104100 },
+]
+
+[[package]]
+name = "pytest"
+version = "8.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8b/6c/62bbd536103af674e227c41a8f3dcd022d591f6eed5facb5a0f31ee33bbc/pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181", size = 1442487 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/77/7440a06a8ead44c7757a64362dd22df5760f9b12dc5f11b6188cd2fc27a0/pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2", size = 342341 },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "5.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/67/00efc8d11b630c56f15f4ad9c7f9223f1e5ec275aaae3fa9118c6a223ad2/pytest-cov-5.0.0.tar.gz", hash = "sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857", size = 63042 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/3a/af5b4fa5961d9a1e6237b530eb87dd04aea6eb83da09d2a4073d81b54ccf/pytest_cov-5.0.0-py3-none-any.whl", hash = "sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652", size = 21990 },
+]
+
+[[package]]
+name = "pytest-order"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1d/66/02ae17461b14a52ce5a29ae2900156b9110d1de34721ccc16ccd79419876/pytest_order-1.3.0.tar.gz", hash = "sha256:51608fec3d3ee9c0adaea94daa124a5c4c1d2bb99b00269f098f414307f23dde", size = 47544 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/73/59b038d1aafca89f8e9936eaa8ffa6bb6138d00459d13a32ce070be4f280/pytest_order-1.3.0-py3-none-any.whl", hash = "sha256:2cd562a21380345dd8d5774aa5fd38b7849b6ee7397ca5f6999bbe6e89f07f6e", size = 14609 },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+]
+
+[[package]]
+name = "pytz"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 },
+]
+
+[[package]]
+name = "pywavelets"
+version = "1.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6e/d4/008dceeb95fafcf141f39393bdfc10921d0b62a325c2794ac533195a1eb3/PyWavelets-1.4.1.tar.gz", hash = "sha256:6437af3ddf083118c26d8f97ab43b0724b956c9f958e9ea788659f6a2834ba93", size = 4589677 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/50/92/a78bf0c3d84afd9b17727cce122c3fdb3860a27bd67b32448c7e64301e7b/PyWavelets-1.4.1-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:d854411eb5ee9cb4bc5d0e66e3634aeb8f594210f6a1bed96dbed57ec70f181c", size = 4365967 },
+    { url = "https://files.pythonhosted.org/packages/f3/66/2bbcad043383d7be3bca2155972adba1d06be3bc5536afbfa22f1cd99688/PyWavelets-1.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:231b0e0b1cdc1112f4af3c24eea7bf181c418d37922a67670e9bf6cfa2d544d4", size = 4269548 },
+    { url = "https://files.pythonhosted.org/packages/07/fe/90ab3b98dfeb2177e1b8c8ccdd4e777e35dfe0aa98723308bd8f1a97fd47/PyWavelets-1.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:754fa5085768227c4f4a26c1e0c78bc509a266d9ebd0eb69a278be7e3ece943c", size = 6748302 },
+    { url = "https://files.pythonhosted.org/packages/3e/fc/651024e8b6e69bef6def2cbe27d520309f4ffc56b8d4885ab7046e1edc6c/PyWavelets-1.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da7b9c006171be1f9ddb12cc6e0d3d703b95f7f43cb5e2c6f5f15d3233fcf202", size = 6836957 },
+    { url = "https://files.pythonhosted.org/packages/51/af/53bcfea50c24cedb202b0c072193af94a1a611b26ab360082791e455b43f/PyWavelets-1.4.1-cp310-cp310-win32.whl", hash = "sha256:67a0d28a08909f21400cb09ff62ba94c064882ffd9e3a6b27880a111211d59bd", size = 4103794 },
+    { url = "https://files.pythonhosted.org/packages/35/12/f1a4f72b5d71497e4200e71e253cc747077d8570b55693faaa7b81fb6dff/PyWavelets-1.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:91d3d393cffa634f0e550d88c0e3f217c96cfb9e32781f2960876f1808d9b45b", size = 4162789 },
+    { url = "https://files.pythonhosted.org/packages/13/e4/86bb218c7926e1da7a52e0696cab120a17c995933f08d8228d9aa83b44c5/PyWavelets-1.4.1-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:64c6bac6204327321db30b775060fbe8e8642316e6bff17f06b9f34936f88875", size = 4349932 },
+    { url = "https://files.pythonhosted.org/packages/94/73/4df43d2e18e68c7ea88177c1fa14a25b5813a51b4953dc94c21f2de039d5/PyWavelets-1.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3f19327f2129fb7977bc59b966b4974dfd72879c093e44a7287500a7032695de", size = 4256446 },
+    { url = "https://files.pythonhosted.org/packages/1d/5e/97ff80a20fb22f723f0c3f6f5f407b12579a560abf7c3a8087d052993dd9/PyWavelets-1.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad987748f60418d5f4138db89d82ba0cb49b086e0cbb8fd5c3ed4a814cfb705e", size = 6964351 },
+    { url = "https://files.pythonhosted.org/packages/de/a1/cd8a30e061f858f219364554b19d4318276c677a51d956c55fb0b134e8b2/PyWavelets-1.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:875d4d620eee655346e3589a16a73790cf9f8917abba062234439b594e706784", size = 7040415 },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/0f9356779440aaaa35ff82479c40a094419f19ab94a3d5f49e090398959b/PyWavelets-1.4.1-cp311-cp311-win32.whl", hash = "sha256:7231461d7a8eb3bdc7aa2d97d9f67ea5a9f8902522818e7e2ead9c2b3408eeb1", size = 4101666 },
+    { url = "https://files.pythonhosted.org/packages/e4/13/9a1632347677e1be27900d9dc922f19bc01440eb8b0c663cea63b35275fc/PyWavelets-1.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:daf0aa79842b571308d7c31a9c43bc99a30b6328e6aea3f50388cd8f69ba7dbc", size = 4160676 },
+    { url = "https://files.pythonhosted.org/packages/2f/52/080267790e23a5186185f2c26d7b774cee754387d1bcb116c7a45f3546f6/PyWavelets-1.4.1-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:ab7da0a17822cd2f6545626946d3b82d1a8e106afc4b50e3387719ba01c7b966", size = 4349347 },
+    { url = "https://files.pythonhosted.org/packages/73/8c/6d50b8e2ee4d12373a63791ad742df1e30ddd5f0f8d1c000c5b6b3afb2c9/PyWavelets-1.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:578af438a02a86b70f1975b546f68aaaf38f28fb082a61ceb799816049ed18aa", size = 4254092 },
+    { url = "https://files.pythonhosted.org/packages/cd/c1/132756d0033b37f4013299ac048bf34d5094673712984edb9e90e8d8a179/PyWavelets-1.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb5ca8d11d3f98e89e65796a2125be98424d22e5ada360a0dbabff659fca0fc", size = 6854556 },
+    { url = "https://files.pythonhosted.org/packages/88/4b/b2b2a6f51e47c091c221bfde976a01a7e5f20e7e5e6341b2b9c4db73d2ed/PyWavelets-1.4.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:058b46434eac4c04dd89aeef6fa39e4b6496a951d78c500b6641fd5b2cc2f9f4", size = 6942852 },
+    { url = "https://files.pythonhosted.org/packages/6c/92/7e900e574575358a5af6ad9f8378d889b1a21e2ba835bae9d0eb7efd505b/PyWavelets-1.4.1-cp38-cp38-win32.whl", hash = "sha256:de7cd61a88a982edfec01ea755b0740e94766e00a1ceceeafef3ed4c85c605cd", size = 4111675 },
+    { url = "https://files.pythonhosted.org/packages/a9/8f/f80ff31e73385b886c35fb9fb1377849f9c43a3c1195ed8dc8ed8dc1bd88/PyWavelets-1.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:7ab8d9db0fe549ab2ee0bea61f614e658dd2df419d5b75fba47baa761e95f8f2", size = 4172202 },
+    { url = "https://files.pythonhosted.org/packages/9f/67/33b37d53da9d225301e30894db5083569aa670b446253b3906fc0e96119e/PyWavelets-1.4.1-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:23bafd60350b2b868076d976bdd92f950b3944f119b4754b1d7ff22b7acbf6c6", size = 4366511 },
+    { url = "https://files.pythonhosted.org/packages/a0/32/eeeaa4de640a84e2cc35c25aea289367059abce0cac84a9987b139a2a25f/PyWavelets-1.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d0e56cd7a53aed3cceca91a04d62feb3a0aca6725b1912d29546c26f6ea90426", size = 4268409 },
+    { url = "https://files.pythonhosted.org/packages/34/c0/a121306b618af45ff7d769e1bd45ed3d6c798dc7f0094e0b56735388d96e/PyWavelets-1.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:030670a213ee8fefa56f6387b0c8e7d970c7f7ad6850dc048bd7c89364771b9b", size = 6824100 },
+    { url = "https://files.pythonhosted.org/packages/5a/98/4549479a32972bdfdd5e75e168219e97f4dfaee535a8308efef7291e8398/PyWavelets-1.4.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71ab30f51ee4470741bb55fc6b197b4a2b612232e30f6ac069106f0156342356", size = 6908506 },
+    { url = "https://files.pythonhosted.org/packages/0d/72/db0ef5ca311627f86de89a7af6055301c67490f4160e725cdbd32eea7700/PyWavelets-1.4.1-cp39-cp39-win32.whl", hash = "sha256:47cac4fa25bed76a45bc781a293c26ac63e8eaae9eb8f9be961758d22b58649c", size = 4111933 },
+    { url = "https://files.pythonhosted.org/packages/02/15/89951f559601fb6755f2231558c33c1b9cbba9e8526906cbc258e27eb53d/PyWavelets-1.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:88aa5449e109d8f5e7f0adef85f7f73b1ab086102865be64421a3a3d02d277f4", size = 4171580 },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 },
+    { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 },
+    { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 },
+    { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 },
+    { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 },
+    { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 },
+    { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 },
+    { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 },
+    { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 },
+    { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 },
+    { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 },
+    { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 },
+    { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 },
+    { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 },
+    { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 },
+    { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 },
+    { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 },
+    { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 },
+    { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 },
+    { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 },
+    { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 },
+    { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 },
+    { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 },
+    { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 },
+    { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 },
+    { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 },
+    { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 },
+    { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 },
+    { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 },
+    { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 },
+    { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 },
+    { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 },
+    { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 },
+    { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 },
+    { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 },
+    { url = "https://files.pythonhosted.org/packages/74/d9/323a59d506f12f498c2097488d80d16f4cf965cee1791eab58b56b19f47a/PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a", size = 183218 },
+    { url = "https://files.pythonhosted.org/packages/74/cc/20c34d00f04d785f2028737e2e2a8254e1425102e730fee1d6396f832577/PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5", size = 728067 },
+    { url = "https://files.pythonhosted.org/packages/20/52/551c69ca1501d21c0de51ddafa8c23a0191ef296ff098e98358f69080577/PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d", size = 757812 },
+    { url = "https://files.pythonhosted.org/packages/fd/7f/2c3697bba5d4aa5cc2afe81826d73dfae5f049458e44732c7a0938baa673/PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083", size = 746531 },
+    { url = "https://files.pythonhosted.org/packages/8c/ab/6226d3df99900e580091bb44258fde77a8433511a86883bd4681ea19a858/PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706", size = 800820 },
+    { url = "https://files.pythonhosted.org/packages/a0/99/a9eb0f3e710c06c5d922026f6736e920d431812ace24aae38228d0d64b04/PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a", size = 145514 },
+    { url = "https://files.pythonhosted.org/packages/75/8a/ee831ad5fafa4431099aa4e078d4c8efd43cd5e48fbc774641d233b683a9/PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff", size = 162702 },
+    { url = "https://files.pythonhosted.org/packages/65/d8/b7a1db13636d7fb7d4ff431593c510c8b8fca920ade06ca8ef20015493c5/PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d", size = 184777 },
+    { url = "https://files.pythonhosted.org/packages/0a/02/6ec546cd45143fdf9840b2c6be8d875116a64076218b61d68e12548e5839/PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f", size = 172318 },
+    { url = "https://files.pythonhosted.org/packages/0e/9a/8cc68be846c972bda34f6c2a93abb644fb2476f4dcc924d52175786932c9/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290", size = 720891 },
+    { url = "https://files.pythonhosted.org/packages/e9/6c/6e1b7f40181bc4805e2e07f4abc10a88ce4648e7e95ff1abe4ae4014a9b2/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12", size = 722614 },
+    { url = "https://files.pythonhosted.org/packages/3d/32/e7bd8535d22ea2874cef6a81021ba019474ace0d13a4819c2a4bce79bd6a/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19", size = 737360 },
+    { url = "https://files.pythonhosted.org/packages/d7/12/7322c1e30b9be969670b672573d45479edef72c9a0deac3bb2868f5d7469/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e", size = 699006 },
+    { url = "https://files.pythonhosted.org/packages/82/72/04fcad41ca56491995076630c3ec1e834be241664c0c09a64c9a2589b507/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725", size = 723577 },
+    { url = "https://files.pythonhosted.org/packages/ed/5e/46168b1f2757f1fcd442bc3029cd8767d88a98c9c05770d8b420948743bb/PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631", size = 144593 },
+    { url = "https://files.pythonhosted.org/packages/19/87/5124b1c1f2412bb95c59ec481eaf936cd32f0fe2a7b16b97b81c4c017a6a/PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8", size = 162312 },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 },
+]
+
+[[package]]
+name = "ruff"
+version = "0.7.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/8b/bc4e0dfa1245b07cf14300e10319b98e958a53ff074c1dd86b35253a8c2a/ruff-0.7.4.tar.gz", hash = "sha256:cd12e35031f5af6b9b93715d8c4f40360070b2041f81273d0527683d5708fce2", size = 3275547 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/4b/f5094719e254829766b807dadb766841124daba75a37da83e292ae5ad12f/ruff-0.7.4-py3-none-linux_armv6l.whl", hash = "sha256:a4919925e7684a3f18e18243cd6bea7cfb8e968a6eaa8437971f681b7ec51478", size = 10447512 },
+    { url = "https://files.pythonhosted.org/packages/9e/1d/3d2d2c9f601cf6044799c5349ff5267467224cefed9b35edf5f1f36486e9/ruff-0.7.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:cfb365c135b830778dda8c04fb7d4280ed0b984e1aec27f574445231e20d6c63", size = 10235436 },
+    { url = "https://files.pythonhosted.org/packages/62/83/42a6ec6216ded30b354b13e0e9327ef75a3c147751aaf10443756cb690e9/ruff-0.7.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:63a569b36bc66fbadec5beaa539dd81e0527cb258b94e29e0531ce41bacc1f20", size = 9888936 },
+    { url = "https://files.pythonhosted.org/packages/4d/26/e1e54893b13046a6ad05ee9b89ee6f71542ba250f72b4c7a7d17c3dbf73d/ruff-0.7.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d06218747d361d06fd2fdac734e7fa92df36df93035db3dc2ad7aa9852cb109", size = 10697353 },
+    { url = "https://files.pythonhosted.org/packages/21/24/98d2e109c4efc02bfef144ec6ea2c3e1217e7ce0cfddda8361d268dfd499/ruff-0.7.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0cea28d0944f74ebc33e9f934238f15c758841f9f5edd180b5315c203293452", size = 10228078 },
+    { url = "https://files.pythonhosted.org/packages/ad/b7/964c75be9bc2945fc3172241b371197bb6d948cc69e28bc4518448c368f3/ruff-0.7.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:80094ecd4793c68b2571b128f91754d60f692d64bc0d7272ec9197fdd09bf9ea", size = 11264823 },
+    { url = "https://files.pythonhosted.org/packages/12/8d/20abdbf705969914ce40988fe71a554a918deaab62c38ec07483e77866f6/ruff-0.7.4-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:997512325c6620d1c4c2b15db49ef59543ef9cd0f4aa8065ec2ae5103cedc7e7", size = 11951855 },
+    { url = "https://files.pythonhosted.org/packages/b8/fc/6519ce58c57b4edafcdf40920b7273dfbba64fc6ebcaae7b88e4dc1bf0a8/ruff-0.7.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00b4cf3a6b5fad6d1a66e7574d78956bbd09abfd6c8a997798f01f5da3d46a05", size = 11516580 },
+    { url = "https://files.pythonhosted.org/packages/37/1a/5ec1844e993e376a86eb2456496831ed91b4398c434d8244f89094758940/ruff-0.7.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7dbdc7d8274e1422722933d1edddfdc65b4336abf0b16dfcb9dedd6e6a517d06", size = 12692057 },
+    { url = "https://files.pythonhosted.org/packages/50/90/76867152b0d3c05df29a74bb028413e90f704f0f6701c4801174ba47f959/ruff-0.7.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e92dfb5f00eaedb1501b2f906ccabfd67b2355bdf117fea9719fc99ac2145bc", size = 11085137 },
+    { url = "https://files.pythonhosted.org/packages/c8/eb/0a7cb6059ac3555243bd026bb21785bbc812f7bbfa95a36c101bd72b47ae/ruff-0.7.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3bd726099f277d735dc38900b6a8d6cf070f80828877941983a57bca1cd92172", size = 10681243 },
+    { url = "https://files.pythonhosted.org/packages/5e/76/2270719dbee0fd35780b05c08a07b7a726c3da9f67d9ae89ef21fc18e2e5/ruff-0.7.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2e32829c429dd081ee5ba39aef436603e5b22335c3d3fff013cd585806a6486a", size = 10319187 },
+    { url = "https://files.pythonhosted.org/packages/9f/e5/39100f72f8ba70bec1bd329efc880dea8b6c1765ea1cb9d0c1c5f18b8d7f/ruff-0.7.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:662a63b4971807623f6f90c1fb664613f67cc182dc4d991471c23c541fee62dd", size = 10803715 },
+    { url = "https://files.pythonhosted.org/packages/a5/89/40e904784f305fb56850063f70a998a64ebba68796d823dde67e89a24691/ruff-0.7.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:876f5e09eaae3eb76814c1d3b68879891d6fde4824c015d48e7a7da4cf066a3a", size = 11162912 },
+    { url = "https://files.pythonhosted.org/packages/8d/1b/dd77503b3875c51e3dbc053fd8367b845ab8b01c9ca6d0c237082732856c/ruff-0.7.4-py3-none-win32.whl", hash = "sha256:75c53f54904be42dd52a548728a5b572344b50d9b2873d13a3f8c5e3b91f5cac", size = 8702767 },
+    { url = "https://files.pythonhosted.org/packages/63/76/253ddc3e89e70165bba952ecca424b980b8d3c2598ceb4fc47904f424953/ruff-0.7.4-py3-none-win_amd64.whl", hash = "sha256:745775c7b39f914238ed1f1b0bebed0b9155a17cd8bc0b08d3c87e4703b990d6", size = 9497534 },
+    { url = "https://files.pythonhosted.org/packages/aa/70/f8724f31abc0b329ca98b33d73c14020168babcf71b0cba3cded5d9d0e66/ruff-0.7.4-py3-none-win_arm64.whl", hash = "sha256:11bff065102c3ae9d3ea4dc9ecdfe5a5171349cdd0787c1fc64761212fc9cf1f", size = 8851590 },
+]
+
+[[package]]
+name = "s3transfer"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/0a/1cdbabf9edd0ea7747efdf6c9ab4e7061b085aa7f9bfc36bb1601563b069/s3transfer-0.10.4.tar.gz", hash = "sha256:29edc09801743c21eb5ecbc617a152df41d3c287f67b615f73e5f750583666a7", size = 145287 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/66/05/7957af15543b8c9799209506df4660cba7afc4cf94bfb60513827e96bed6/s3transfer-0.10.4-py3-none-any.whl", hash = "sha256:244a76a24355363a68164241438de1b72f8781664920260c48465896b712a41e", size = 83175 },
+]
+
+[[package]]
+name = "scikit-image"
+version = "0.21.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "imageio" },
+    { name = "lazy-loader" },
+    { name = "networkx" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pywavelets" },
+    { name = "scipy" },
+    { name = "tifffile" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1d/c2/a54d5e6e2d6708e0722a1aaccef4b7cc1e6df6f76c8b4ce98cd6d0c332c3/scikit_image-0.21.0.tar.gz", hash = "sha256:b33e823c54e6f11873ea390ee49ef832b82b9f70752c8759efd09d5a4e3d87f0", size = 22720419 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/a1/6bc36ba38fe9312271cce46cf2025fcc63be096131747a8f41522a57aaef/scikit_image-0.21.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:978ac3302252155a8556cdfe067bad2d18d5ccef4e91c2f727bc564ed75566bc", size = 12987373 },
+    { url = "https://files.pythonhosted.org/packages/e0/f7/0ec3a2fbed785259176eb2eee7b254fc68c653028907602231cc8ba09da0/scikit_image-0.21.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:82c22e008527e5ee26ab08e3ce919998ef164d538ff30b9e5764b223cfda06b1", size = 12419386 },
+    { url = "https://files.pythonhosted.org/packages/ee/5b/3fe767d6ef7cbcf4894355e5905665f99237c5de465a8ca959a05d2320bc/scikit_image-0.21.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd29d2631d3e975c377066acfc1f4cb2cc95e2257cf70e7fedfcb96441096e88", size = 13207325 },
+    { url = "https://files.pythonhosted.org/packages/70/a9/a9f63dde69ac5a4451d8a0ebdde95824ec31aafcae1c77658a9058e27bb7/scikit_image-0.21.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c6c12925ceb9f3aede555921e26642d601b2d37d1617002a2636f2cb5178ae2f", size = 13760602 },
+    { url = "https://files.pythonhosted.org/packages/f3/93/65601f7577d6fd49ec23bf8fb58c04d8170b06a1544452ae2ea9f59bf11f/scikit_image-0.21.0-cp310-cp310-win_amd64.whl", hash = "sha256:1f538d4de77e4f3225d068d9ea2965bed3f7dda7f457a8f89634fa22ffb9ad8c", size = 22777245 },
+    { url = "https://files.pythonhosted.org/packages/08/53/f28cfb52248665b42db7e45a36ffc3a304fef46b308e5065fe2046e78daf/scikit_image-0.21.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ec9bab6920ac43037d7434058b67b5778d42c60f67b8679239f48a471e7ed6f8", size = 12911110 },
+    { url = "https://files.pythonhosted.org/packages/20/54/06f821fd78c24f7047629dc4c8ed948101fc91fdf660ee3263d870220ae8/scikit_image-0.21.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:a54720430dba833ffbb6dedd93d9f0938c5dd47d20ab9ba3e4e61c19d95f6f19", size = 12333056 },
+    { url = "https://files.pythonhosted.org/packages/31/cf/9e8e819a8d90fb74ec183a0c3e8e182587929845c93779f99439cd270f10/scikit_image-0.21.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e40dd102da14cdadc09210f930b4556c90ff8f99cd9d8bcccf9f73a86c44245", size = 13204303 },
+    { url = "https://files.pythonhosted.org/packages/22/c3/c5f3c351d6337a18d07c3fb04475626c106cd3dc3d59b85ec50d07656db0/scikit_image-0.21.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff5719c7eb99596a39c3e1d9b564025bae78ecf1da3ee6842d34f6965b5f1474", size = 13726119 },
+    { url = "https://files.pythonhosted.org/packages/08/c0/8085c5fd2f7f7514a0c5031b666171d5828ac5b3c9cf5d0ecd19688d5407/scikit_image-0.21.0-cp311-cp311-win_amd64.whl", hash = "sha256:146c3824253eee9ff346c4ad10cb58376f91aefaf4a4bb2fe11aa21691f7de76", size = 22753693 },
+    { url = "https://files.pythonhosted.org/packages/35/e4/d5d1574d09f30a4df757edf4213ce8e764aebe0f1642475cf384f9fa33bb/scikit_image-0.21.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4e1b09f81a99c9c390215929194847b3cd358550b4b65bb6e42c5393d69cb74a", size = 12886049 },
+    { url = "https://files.pythonhosted.org/packages/62/9b/8fd51371f3fd4ce06092d1f4740ec5a874a996727117e076c03755e8c777/scikit_image-0.21.0-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:9f7b5fb4a22f0d5ae0fa13beeb887c925280590145cd6d8b2630794d120ff7c7", size = 12315195 },
+    { url = "https://files.pythonhosted.org/packages/fa/2b/ffecc6f29b48d1d46dc3bb7b4c908490260c3a0d69ac2d248d846b90d505/scikit_image-0.21.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4814033717f0b6491fee252facb9df92058d6a72ab78dd6408a50f3915a88b8", size = 13304683 },
+    { url = "https://files.pythonhosted.org/packages/33/29/1d696450464d6e13358d3ef185a1fb14a11181c5dab1eb2837c02be86373/scikit_image-0.21.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b0d6ed6502cca0c9719c444caafa0b8cda0f9e29e01ca42f621a240073284be", size = 13870072 },
+    { url = "https://files.pythonhosted.org/packages/d7/d1/a4c715ad640c9eb0daaa77c4ce561b06e086bec44cbc79083e3548b00b76/scikit_image-0.21.0-cp38-cp38-win_amd64.whl", hash = "sha256:9194cb7bc21215fde6c1b1e9685d312d2aa8f65ea9736bc6311126a91c860032", size = 22712424 },
+    { url = "https://files.pythonhosted.org/packages/ac/96/6a64d241498380dc5f0dca8e48981cd610d31d661a59f90d5ac242546906/scikit_image-0.21.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:54df1ddc854f37a912d42bc724e456e86858107e94048a81a27720bc588f9937", size = 13011056 },
+    { url = "https://files.pythonhosted.org/packages/c4/09/0b465a48f9bc7e848538f82e62811978932132b1edd50da758a9243cef5a/scikit_image-0.21.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:c01e3ab0a1fabfd8ce30686d4401b7ed36e6126c9d4d05cb94abf6bdc46f7ac9", size = 12424218 },
+    { url = "https://files.pythonhosted.org/packages/2f/35/fb5f6a7d46c5dfcbb44d55cff39eb159e74752389097deee1af18a1447ce/scikit_image-0.21.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ef5d8d1099317b7b315b530348cbfa68ab8ce32459de3c074d204166951025c", size = 13313982 },
+    { url = "https://files.pythonhosted.org/packages/19/bd/a53569a0a698d925eb46dbea0bd3b6b62e7287a9ec88b5a03efa8ebd5b14/scikit_image-0.21.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78b1e96c59cab640ca5c5b22c501524cfaf34cbe0cb51ba73bd9a9ede3fb6e1d", size = 13828794 },
+    { url = "https://files.pythonhosted.org/packages/32/b2/1811645651153407f1e715b75afe9962d87582bee70b42c8671c255f8fe6/scikit_image-0.21.0-cp39-cp39-win_amd64.whl", hash = "sha256:9cffcddd2a5594c0a06de2ae3e1e25d662745a26f94fda31520593669677c010", size = 22896233 },
+]
+
+[[package]]
+name = "scikit-learn"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "joblib" },
+    { name = "numpy" },
+    { name = "scipy" },
+    { name = "threadpoolctl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/00/835e3d280fdd7784e76bdef91dd9487582d7951a7254f59fc8004fc8b213/scikit-learn-1.3.2.tar.gz", hash = "sha256:a2f54c76accc15a34bfb9066e6c7a56c1e7235dda5762b990792330b52ccfb05", size = 7510251 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0d/53/570b55a6e10b8694ac1e3024d2df5cd443f1b4ff6d28430845da8b9019b3/scikit_learn-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e326c0eb5cf4d6ba40f93776a20e9a7a69524c4db0757e7ce24ba222471ee8a1", size = 10209999 },
+    { url = "https://files.pythonhosted.org/packages/70/d0/50ace22129f79830e3cf682d0a2bd4843ef91573299d43112d52790163a8/scikit_learn-1.3.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:535805c2a01ccb40ca4ab7d081d771aea67e535153e35a1fd99418fcedd1648a", size = 9479353 },
+    { url = "https://files.pythonhosted.org/packages/8f/46/fcc35ed7606c50d3072eae5a107a45cfa5b7f5fa8cc48610edd8cc8e8550/scikit_learn-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1215e5e58e9880b554b01187b8c9390bf4dc4692eedeaf542d3273f4785e342c", size = 10304705 },
+    { url = "https://files.pythonhosted.org/packages/d0/0b/26ad95cf0b747be967b15fb71a06f5ac67aba0fd2f9cd174de6edefc4674/scikit_learn-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ee107923a623b9f517754ea2f69ea3b62fc898a3641766cb7deb2f2ce450161", size = 10827807 },
+    { url = "https://files.pythonhosted.org/packages/69/8a/cf17d6443f5f537e099be81535a56ab68a473f9393fbffda38cd19899fc8/scikit_learn-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:35a22e8015048c628ad099da9df5ab3004cdbf81edc75b396fd0cff8699ac58c", size = 9255427 },
+    { url = "https://files.pythonhosted.org/packages/08/5d/e5acecd6e99a6b656e42e7a7b18284e2f9c9f512e8ed6979e1e75d25f05f/scikit_learn-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6fb6bc98f234fda43163ddbe36df8bcde1d13ee176c6dc9b92bb7d3fc842eb66", size = 10116376 },
+    { url = "https://files.pythonhosted.org/packages/40/c6/2e91eefb757822e70d351e02cc38d07c137212ae7c41ac12746415b4860a/scikit_learn-1.3.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:18424efee518a1cde7b0b53a422cde2f6625197de6af36da0b57ec502f126157", size = 9383415 },
+    { url = "https://files.pythonhosted.org/packages/fa/fd/b3637639e73bb72b12803c5245f2a7299e09b2acd85a0f23937c53369a1c/scikit_learn-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3271552a5eb16f208a6f7f617b8cc6d1f137b52c8a1ef8edf547db0259b2c9fb", size = 10279163 },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/d3ff6091406bc2207e0adb832ebd15e40ac685811c7e2e3b432bfd969b71/scikit_learn-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc4144a5004a676d5022b798d9e573b05139e77f271253a4703eed295bde0433", size = 10884422 },
+    { url = "https://files.pythonhosted.org/packages/4e/ba/ce9bd1cd4953336a0e213b29cb80bb11816f2a93de8c99f88ef0b446ad0c/scikit_learn-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:67f37d708f042a9b8d59551cf94d30431e01374e00dc2645fa186059c6c5d78b", size = 9207060 },
+    { url = "https://files.pythonhosted.org/packages/26/7e/2c3b82c8c29aa384c8bf859740419278627d2cdd0050db503c8840e72477/scikit_learn-1.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:8db94cd8a2e038b37a80a04df8783e09caac77cbe052146432e67800e430c028", size = 9979322 },
+    { url = "https://files.pythonhosted.org/packages/cf/fc/6c52ffeb587259b6b893b7cac268f1eb1b5426bcce1aa20e53523bfe6944/scikit_learn-1.3.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:61a6efd384258789aa89415a410dcdb39a50e19d3d8410bd29be365bcdd512d5", size = 9270688 },
+    { url = "https://files.pythonhosted.org/packages/e5/a7/6f4ae76f72ae9de162b97acbf1f53acbe404c555f968d13da21e4112a002/scikit_learn-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb06f8dce3f5ddc5dee1715a9b9f19f20d295bed8e3cd4fa51e1d050347de525", size = 10280398 },
+    { url = "https://files.pythonhosted.org/packages/5d/b7/ee35904c07a0666784349529412fbb9814a56382b650d30fd9d6be5e5054/scikit_learn-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5b2de18d86f630d68fe1f87af690d451388bb186480afc719e5f770590c2ef6c", size = 10796478 },
+    { url = "https://files.pythonhosted.org/packages/fe/6b/db949ed5ac367987b1f250f070f340b7715d22f0c9c965bdf07de6ca75a3/scikit_learn-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:0402638c9a7c219ee52c94cbebc8fcb5eb9fe9c773717965c1f4185588ad3107", size = 9133979 },
+    { url = "https://files.pythonhosted.org/packages/e3/52/fd60b0b022af41fbf3463587ddc719288f0f2d4e46603ab3184996cd5f04/scikit_learn-1.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a19f90f95ba93c1a7f7924906d0576a84da7f3b2282ac3bfb7a08a32801add93", size = 10064879 },
+    { url = "https://files.pythonhosted.org/packages/a4/62/92e9cec3deca8b45abf62dd8f6469d688b3f28b9c170809fcc46f110b523/scikit_learn-1.3.2-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:b8692e395a03a60cd927125eef3a8e3424d86dde9b2370d544f0ea35f78a8073", size = 9373934 },
+    { url = "https://files.pythonhosted.org/packages/49/81/91585dc83ec81dcd52e934f6708bf350b06949d8bfa13bf3b711b851c3f4/scikit_learn-1.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15e1e94cc23d04d39da797ee34236ce2375ddea158b10bee3c343647d615581d", size = 10499159 },
+    { url = "https://files.pythonhosted.org/packages/3f/48/6fdd99f5717045f9984616b5c2ec683d6286d30c0ac234563062132b83ab/scikit_learn-1.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:785a2213086b7b1abf037aeadbbd6d67159feb3e30263434139c98425e3dcfcf", size = 11067392 },
+    { url = "https://files.pythonhosted.org/packages/52/2d/ad6928a578c78bb0e44e34a5a922818b14c56716b81d145924f1f291416f/scikit_learn-1.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:64381066f8aa63c2710e6b56edc9f0894cc7bf59bd71b8ce5613a4559b6145e0", size = 9257871 },
+    { url = "https://files.pythonhosted.org/packages/f8/67/584acfc492ae1bd293d80c7a8c57ba7456e4e415c64869b7c240679eaf78/scikit_learn-1.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6c43290337f7a4b969d207e620658372ba3c1ffb611f8bc2b6f031dc5c6d1d03", size = 10232286 },
+    { url = "https://files.pythonhosted.org/packages/20/0f/51e3ccdc87c25e2e33bf7962249ff8c5ab1d6aed0144fb003348ce8bd352/scikit_learn-1.3.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:dc9002fc200bed597d5d34e90c752b74df516d592db162f756cc52836b38fe0e", size = 9504918 },
+    { url = "https://files.pythonhosted.org/packages/61/2e/5bbf3c9689d2911b65297fb5861c4257e54c797b3158c9fca8a5c576644b/scikit_learn-1.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d08ada33e955c54355d909b9c06a4789a729977f165b8bae6f225ff0a60ec4a", size = 10358127 },
+    { url = "https://files.pythonhosted.org/packages/25/89/dce01a35d354159dcc901e3c7e7eb3fe98de5cb3639c6cd39518d8830caa/scikit_learn-1.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:763f0ae4b79b0ff9cca0bf3716bcc9915bdacff3cebea15ec79652d1cc4fa5c9", size = 10890482 },
+    { url = "https://files.pythonhosted.org/packages/1c/49/30ffcac5af06d08dfdd27da322ce31a373b733711bb272941877c1e4794a/scikit_learn-1.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:ed932ea780517b00dae7431e031faae6b49b20eb6950918eb83bd043237950e0", size = 9331050 },
+]
+
+[[package]]
+name = "scipy"
+version = "1.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/84/a9/2bf119f3f9cff1f376f924e39cfae18dec92a1514784046d185731301281/scipy-1.10.1.tar.gz", hash = "sha256:2cf9dfb80a7b4589ba4c40ce7588986d6d5cebc5457cad2c2880f6bc2d42f3a5", size = 42407997 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/ac/b1f1bbf7b01d96495f35be003b881f10f85bf6559efb6e9578da832c2140/scipy-1.10.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e7354fd7527a4b0377ce55f286805b34e8c54b91be865bac273f527e1b839019", size = 35093243 },
+    { url = "https://files.pythonhosted.org/packages/ea/e5/452086ebed676ce4000ceb5eeeb0ee4f8c6f67c7e70fb9323a370ff95c1f/scipy-1.10.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:4b3f429188c66603a1a5c549fb414e4d3bdc2a24792e061ffbd607d3d75fd84e", size = 28772969 },
+    { url = "https://files.pythonhosted.org/packages/04/0b/a1b119c869b79a2ab459b7f9fd7e2dea75a9c7d432e64e915e75586bd00b/scipy-1.10.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1553b5dcddd64ba9a0d95355e63fe6c3fc303a8fd77c7bc91e77d61363f7433f", size = 30886961 },
+    { url = "https://files.pythonhosted.org/packages/1f/4b/3bacad9a166350cb2e518cea80ab891016933cc1653f15c90279512c5fa9/scipy-1.10.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c0ff64b06b10e35215abce517252b375e580a6125fd5fdf6421b98efbefb2d2", size = 34422544 },
+    { url = "https://files.pythonhosted.org/packages/ec/e3/b06ac3738bf365e89710205a471abe7dceec672a51c244b469bc5d1291c7/scipy-1.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:fae8a7b898c42dffe3f7361c40d5952b6bf32d10c4569098d276b4c547905ee1", size = 42484848 },
+    { url = "https://files.pythonhosted.org/packages/e7/53/053cd3669be0d474deae8fe5f757bff4c4f480b8a410231e0631c068873d/scipy-1.10.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0f1564ea217e82c1bbe75ddf7285ba0709ecd503f048cb1236ae9995f64217bd", size = 35003170 },
+    { url = "https://files.pythonhosted.org/packages/0d/3e/d05b9de83677195886fb79844fcca19609a538db63b1790fa373155bc3cf/scipy-1.10.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:d925fa1c81b772882aa55bcc10bf88324dadb66ff85d548c71515f6689c6dac5", size = 28717513 },
+    { url = "https://files.pythonhosted.org/packages/a5/3d/b69746c50e44893da57a68457da3d7e5bb75f6a37fbace3769b70d017488/scipy-1.10.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaea0a6be54462ec027de54fca511540980d1e9eea68b2d5c1dbfe084797be35", size = 30687257 },
+    { url = "https://files.pythonhosted.org/packages/21/cd/fe2d4af234b80dc08c911ce63fdaee5badcdde3e9bcd9a68884580652ef0/scipy-1.10.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15a35c4242ec5f292c3dd364a7c71a61be87a3d4ddcc693372813c0b73c9af1d", size = 34124096 },
+    { url = "https://files.pythonhosted.org/packages/65/76/903324159e4a3566e518c558aeb21571d642f781d842d8dd0fd9c6b0645a/scipy-1.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:43b8e0bcb877faf0abfb613d51026cd5cc78918e9530e375727bf0625c82788f", size = 42238704 },
+    { url = "https://files.pythonhosted.org/packages/a0/e3/37508a11dae501349d7c16e4dd18c706a023629eedc650ee094593887a89/scipy-1.10.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5678f88c68ea866ed9ebe3a989091088553ba12c6090244fdae3e467b1139c35", size = 35041063 },
+    { url = "https://files.pythonhosted.org/packages/93/4a/50c436de1353cce8b66b26e49a687f10b91fe7465bf34e4565d810153003/scipy-1.10.1-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:39becb03541f9e58243f4197584286e339029e8908c46f7221abeea4b749fa88", size = 28797694 },
+    { url = "https://files.pythonhosted.org/packages/d2/b5/ff61b79ad0ebd15d87ade10e0f4e80114dd89fac34a5efade39e99048c91/scipy-1.10.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bce5869c8d68cf383ce240e44c1d9ae7c06078a9396df68ce88a1230f93a30c1", size = 31024657 },
+    { url = "https://files.pythonhosted.org/packages/69/f0/fb07a9548e48b687b8bf2fa81d71aba9cfc548d365046ca1c791e24db99d/scipy-1.10.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07c3457ce0b3ad5124f98a86533106b643dd811dd61b548e78cf4c8786652f6f", size = 34540352 },
+    { url = "https://files.pythonhosted.org/packages/32/8e/7f403535ddf826348c9b8417791e28712019962f7e90ff845896d6325d09/scipy-1.10.1-cp38-cp38-win_amd64.whl", hash = "sha256:049a8bbf0ad95277ffba9b3b7d23e5369cc39e66406d60422c8cfef40ccc8415", size = 42215036 },
+    { url = "https://files.pythonhosted.org/packages/d9/7d/78b8035bc93c869b9f17261c87aae97a9cdb937f65f0d453c2831aa172fc/scipy-1.10.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:cd9f1027ff30d90618914a64ca9b1a77a431159df0e2a195d8a9e8a04c78abf9", size = 35158611 },
+    { url = "https://files.pythonhosted.org/packages/e7/f0/55d81813b1a4cb79ce7dc8290eac083bf38bfb36e1ada94ea13b7b1a5f79/scipy-1.10.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:79c8e5a6c6ffaf3a2262ef1be1e108a035cf4f05c14df56057b64acc5bebffb6", size = 28902591 },
+    { url = "https://files.pythonhosted.org/packages/77/d1/722c457b319eed1d642e0a14c9be37eb475f0e6ed1f3401fa480d5d6d36e/scipy-1.10.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51af417a000d2dbe1ec6c372dfe688e041a7084da4fdd350aeb139bd3fb55353", size = 30960654 },
+    { url = "https://files.pythonhosted.org/packages/5d/30/b2a2a5bf1a3beefb7609fb871dcc6aef7217c69cef19a4631b7ab5622a8a/scipy-1.10.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b4735d6c28aad3cdcf52117e0e91d6b39acd4272f3f5cd9907c24ee931ad601", size = 34458863 },
+    { url = "https://files.pythonhosted.org/packages/35/20/0ec6246bbb43d18650c9a7cad6602e1a84fd8f9564a9b84cc5faf1e037d0/scipy-1.10.1-cp39-cp39-win_amd64.whl", hash = "sha256:7ff7f37b1bf4417baca958d254e8e2875d0cc23aaadbe65b3d5b3077b0eb23ea", size = 42509516 },
+]
+
+[[package]]
+name = "shapely"
+version = "2.0.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4a/89/0d20bac88016be35ff7d3c0c2ae64b477908f1b1dfa540c5d69ac7af07fe/shapely-2.0.6.tar.gz", hash = "sha256:997f6159b1484059ec239cacaa53467fd8b5564dabe186cd84ac2944663b0bf6", size = 282361 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/d4/f84bbbdb7771f5b9ade94db2398b256cf1471f1eb0ca8afbe0f6ca725d5a/shapely-2.0.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:29a34e068da2d321e926b5073539fd2a1d4429a2c656bd63f0bd4c8f5b236d0b", size = 1449635 },
+    { url = "https://files.pythonhosted.org/packages/03/10/bd6edb66ed0a845f0809f7ce653596f6fd9c6be675b3653872f47bf49f82/shapely-2.0.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c84c3f53144febf6af909d6b581bc05e8785d57e27f35ebaa5c1ab9baba13b", size = 1296756 },
+    { url = "https://files.pythonhosted.org/packages/af/09/6374c11cb493a9970e8c04d7be25f578a37f6494a2fecfbed3a447b16b2c/shapely-2.0.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ad2fae12dca8d2b727fa12b007e46fbc522148a584f5d6546c539f3464dccde", size = 2381960 },
+    { url = "https://files.pythonhosted.org/packages/2b/a6/302e0d9c210ccf4d1ffadf7ab941797d3255dcd5f93daa73aaf116a4db39/shapely-2.0.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3304883bd82d44be1b27a9d17f1167fda8c7f5a02a897958d86c59ec69b705e", size = 2468133 },
+    { url = "https://files.pythonhosted.org/packages/8c/be/e448681dc485f2931d4adee93d531fce93608a3ee59433303cc1a46e21a5/shapely-2.0.6-cp310-cp310-win32.whl", hash = "sha256:3ec3a0eab496b5e04633a39fa3d5eb5454628228201fb24903d38174ee34565e", size = 1294982 },
+    { url = "https://files.pythonhosted.org/packages/cd/4c/6f4a6fc085e3be01c4c9de0117a2d373bf9fec5f0426cf4d5c94090a5a4d/shapely-2.0.6-cp310-cp310-win_amd64.whl", hash = "sha256:28f87cdf5308a514763a5c38de295544cb27429cfa655d50ed8431a4796090c4", size = 1441141 },
+    { url = "https://files.pythonhosted.org/packages/37/15/269d8e1f7f658a37e61f7028683c546f520e4e7cedba1e32c77ff9d3a3c7/shapely-2.0.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5aeb0f51a9db176da9a30cb2f4329b6fbd1e26d359012bb0ac3d3c7781667a9e", size = 1449578 },
+    { url = "https://files.pythonhosted.org/packages/37/63/e182e43081fffa0a2d970c480f2ef91647a6ab94098f61748c23c2a485f2/shapely-2.0.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9a7a78b0d51257a367ee115f4d41ca4d46edbd0dd280f697a8092dd3989867b2", size = 1296792 },
+    { url = "https://files.pythonhosted.org/packages/6e/5a/d019f69449329dcd517355444fdb9ddd58bec5e080b8bdba007e8e4c546d/shapely-2.0.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f32c23d2f43d54029f986479f7c1f6e09c6b3a19353a3833c2ffb226fb63a855", size = 2443997 },
+    { url = "https://files.pythonhosted.org/packages/25/aa/53f145e5a610a49af9ac49f2f1be1ec8659ebd5c393d66ac94e57c83b00e/shapely-2.0.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3dc9fb0eb56498912025f5eb352b5126f04801ed0e8bdbd867d21bdbfd7cbd0", size = 2528334 },
+    { url = "https://files.pythonhosted.org/packages/64/64/0c7b0a22b416d36f6296b92bb4219d82b53d0a7c47e16fd0a4c85f2f117c/shapely-2.0.6-cp311-cp311-win32.whl", hash = "sha256:d93b7e0e71c9f095e09454bf18dad5ea716fb6ced5df3cb044564a00723f339d", size = 1294669 },
+    { url = "https://files.pythonhosted.org/packages/b1/5a/6a67d929c467a1973b6bb9f0b00159cc343b02bf9a8d26db1abd2f87aa23/shapely-2.0.6-cp311-cp311-win_amd64.whl", hash = "sha256:c02eb6bf4cfb9fe6568502e85bb2647921ee49171bcd2d4116c7b3109724ef9b", size = 1442032 },
+    { url = "https://files.pythonhosted.org/packages/46/77/efd9f9d4b6a762f976f8b082f54c9be16f63050389500fb52e4f6cc07c1a/shapely-2.0.6-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cec9193519940e9d1b86a3b4f5af9eb6910197d24af02f247afbfb47bcb3fab0", size = 1450326 },
+    { url = "https://files.pythonhosted.org/packages/68/53/5efa6e7a4036a94fe6276cf7bbb298afded51ca3396b03981ad680c8cc7d/shapely-2.0.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83b94a44ab04a90e88be69e7ddcc6f332da7c0a0ebb1156e1c4f568bbec983c3", size = 1298480 },
+    { url = "https://files.pythonhosted.org/packages/88/a2/1be1db4fc262e536465a52d4f19d85834724fedf2299a1b9836bc82fe8fa/shapely-2.0.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:537c4b2716d22c92036d00b34aac9d3775e3691f80c7aa517c2c290351f42cd8", size = 2439311 },
+    { url = "https://files.pythonhosted.org/packages/d5/7d/9a57e187cbf2fbbbdfd4044a4f9ce141c8d221f9963750d3b001f0ec080d/shapely-2.0.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98fea108334be345c283ce74bf064fa00cfdd718048a8af7343c59eb40f59726", size = 2524835 },
+    { url = "https://files.pythonhosted.org/packages/6d/0a/f407509ab56825f39bf8cfce1fb410238da96cf096809c3e404e5bc71ea1/shapely-2.0.6-cp312-cp312-win32.whl", hash = "sha256:42fd4cd4834747e4990227e4cbafb02242c0cffe9ce7ef9971f53ac52d80d55f", size = 1295613 },
+    { url = "https://files.pythonhosted.org/packages/7b/b3/857afd9dfbfc554f10d683ac412eac6fa260d1f4cd2967ecb655c57e831a/shapely-2.0.6-cp312-cp312-win_amd64.whl", hash = "sha256:665990c84aece05efb68a21b3523a6b2057e84a1afbef426ad287f0796ef8a48", size = 1442539 },
+    { url = "https://files.pythonhosted.org/packages/34/e8/d164ef5b0eab86088cde06dee8415519ffd5bb0dd1bd9d021e640e64237c/shapely-2.0.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:42805ef90783ce689a4dde2b6b2f261e2c52609226a0438d882e3ced40bb3013", size = 1445344 },
+    { url = "https://files.pythonhosted.org/packages/ce/e2/9fba7ac142f7831757a10852bfa465683724eadbc93d2d46f74a16f9af04/shapely-2.0.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6d2cb146191a47bd0cee8ff5f90b47547b82b6345c0d02dd8b25b88b68af62d7", size = 1296182 },
+    { url = "https://files.pythonhosted.org/packages/cf/dc/790d4bda27d196cd56ec66975eaae3351c65614cafd0e16ddde39ec9fb92/shapely-2.0.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3fdef0a1794a8fe70dc1f514440aa34426cc0ae98d9a1027fb299d45741c381", size = 2423426 },
+    { url = "https://files.pythonhosted.org/packages/af/b0/f8169f77eac7392d41e231911e0095eb1148b4d40c50ea9e34d999c89a7e/shapely-2.0.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c665a0301c645615a107ff7f52adafa2153beab51daf34587170d85e8ba6805", size = 2513249 },
+    { url = "https://files.pythonhosted.org/packages/f6/1d/a8c0e9ab49ff2f8e4dedd71b0122eafb22a18ad7e9d256025e1f10c84704/shapely-2.0.6-cp313-cp313-win32.whl", hash = "sha256:0334bd51828f68cd54b87d80b3e7cee93f249d82ae55a0faf3ea21c9be7b323a", size = 1294848 },
+    { url = "https://files.pythonhosted.org/packages/23/38/2bc32dd1e7e67a471d4c60971e66df0bdace88656c47a9a728ace0091075/shapely-2.0.6-cp313-cp313-win_amd64.whl", hash = "sha256:d37d070da9e0e0f0a530a621e17c0b8c3c9d04105655132a87cfff8bd77cc4c2", size = 1441371 },
+    { url = "https://files.pythonhosted.org/packages/39/ec/c5c62e98155a89e3bdd1cd14bfe9c504b1ab2c18a0431f4ddf1ea2f10a5b/shapely-2.0.6-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c6d88ade96bf02f6bfd667ddd3626913098e243e419a0325ebef2bbd481d1eb6", size = 1450375 },
+    { url = "https://files.pythonhosted.org/packages/27/f7/92feb389e40fc4d64ec160523ed9a0a9115517880abbc6c8a308e7da87b1/shapely-2.0.6-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8b3b818c4407eaa0b4cb376fd2305e20ff6df757bf1356651589eadc14aab41b", size = 1297627 },
+    { url = "https://files.pythonhosted.org/packages/d9/7c/e2e4b6eace75fad4349b8834f67672574888636d1520396d9274c9dc1d9e/shapely-2.0.6-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1bbc783529a21f2bd50c79cef90761f72d41c45622b3e57acf78d984c50a5d13", size = 2410496 },
+    { url = "https://files.pythonhosted.org/packages/ad/a0/7d303b58cdfd01e6c49278e0c969b2023ccbc0698316c478decd9ad863ed/shapely-2.0.6-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2423f6c0903ebe5df6d32e0066b3d94029aab18425ad4b07bf98c3972a6e25a1", size = 2498668 },
+    { url = "https://files.pythonhosted.org/packages/75/9b/5bc6960fba2f4ab629f2dcf5c68185793e143e14a9aa8773a7b103076510/shapely-2.0.6-cp38-cp38-win32.whl", hash = "sha256:2de00c3bfa80d6750832bde1d9487e302a6dd21d90cb2f210515cefdb616e5f5", size = 1296593 },
+    { url = "https://files.pythonhosted.org/packages/ed/12/f1518b49e1e34b49a1d33577e6fe04c0682e2cded33e21ba2ef2752137b9/shapely-2.0.6-cp38-cp38-win_amd64.whl", hash = "sha256:3a82d58a1134d5e975f19268710e53bddd9c473743356c90d97ce04b73e101ee", size = 1457026 },
+    { url = "https://files.pythonhosted.org/packages/9d/6f/19fda412323f512e21b8888523596177070bca29a80d1b70f4b6a5e7869f/shapely-2.0.6-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:392f66f458a0a2c706254f473290418236e52aa4c9b476a072539d63a2460595", size = 1451236 },
+    { url = "https://files.pythonhosted.org/packages/bc/f5/5dfd13e90fe881560b4b1196e47fab48d6469c33d0b78d0f57a5e10bd409/shapely-2.0.6-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:eba5bae271d523c938274c61658ebc34de6c4b33fdf43ef7e938b5776388c1be", size = 1298209 },
+    { url = "https://files.pythonhosted.org/packages/76/89/6be88c828e2c671dfdd5b0c875d08c8573c6f1bac759f297b166e0b2c64c/shapely-2.0.6-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7060566bc4888b0c8ed14b5d57df8a0ead5c28f9b69fb6bed4476df31c51b0af", size = 2389098 },
+    { url = "https://files.pythonhosted.org/packages/a5/b2/6a4589439880244f86c1d3061efd91faf8ec21e646df18730810b6d59481/shapely-2.0.6-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b02154b3e9d076a29a8513dffcb80f047a5ea63c897c0cd3d3679f29363cf7e5", size = 2473382 },
+    { url = "https://files.pythonhosted.org/packages/42/dd/2a039361d249dc84f0470173356c36d74516fe2978dfdde98197618f4e5c/shapely-2.0.6-cp39-cp39-win32.whl", hash = "sha256:44246d30124a4f1a638a7d5419149959532b99dfa25b54393512e6acc9c211ac", size = 1296873 },
+    { url = "https://files.pythonhosted.org/packages/a7/68/0e4b9aab76d2b7f44013dc98aa16c7f9e33dd1b34088140fb15664967e8b/shapely-2.0.6-cp39-cp39-win_amd64.whl", hash = "sha256:2b542d7f1dbb89192d3512c52b679c822ba916f93479fa5d4fc2fe4fa0b3c9e8", size = 1442993 },
+]
+
+[[package]]
+name = "six"
+version = "1.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/39/171f1c67cd00715f190ba0b100d606d440a28c93c7714febeca8b79af85e/six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926", size = 34041 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/5a/e7c31adbe875f2abbb91bd84cf2dc52d792b5a01506781dbcf25c91daf11/six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254", size = 11053 },
+]
+
+[[package]]
+name = "tabulate"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252 },
+]
+
+[[package]]
+name = "threadpoolctl"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/55/b5148dcbf72f5cde221f8bfe3b6a540da7aa1842f6b491ad979a6c8b84af/threadpoolctl-3.5.0.tar.gz", hash = "sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107", size = 41936 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/2c/ffbf7a134b9ab11a67b0cf0726453cedd9c5043a4fe7a35d1cefa9a1bcfb/threadpoolctl-3.5.0-py3-none-any.whl", hash = "sha256:56c1e26c150397e58c4926da8eeee87533b1e32bef131bd4bf6a2f45f3185467", size = 18414 },
+]
+
+[[package]]
+name = "tifffile"
+version = "2023.7.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/22/4d19feaba862f06f6392499d5617f96b0d8eb9a876e33e9b6aab292b88f2/tifffile-2023.7.10.tar.gz", hash = "sha256:c06ec460926d16796eeee249a560bcdddf243daae36ac62af3c84a953cd60b4a", size = 345689 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/a3/68d17088a4f09565bc7341fd20490da8191ec4cddde479daaabbe07bb603/tifffile-2023.7.10-py3-none-any.whl", hash = "sha256:94dfdec321ace96abbfe872a66cfd824800c099a2db558443453eebc2c11b304", size = 220889 },
+]
+
+[[package]]
+name = "tomli"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1e/e4/1b6cbcc82d8832dd0ce34767d5c560df8a3547ad8cbc427f34601415930a/tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8", size = 16622 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/f7/4da0ffe1892122c9ea096c57f64c2753ae5dd3ce85488802d11b0992cc6d/tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391", size = 13750 },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "platform_system == 'Windows'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e8/4f/0153c21dc5779a49a0598c445b1978126b1344bab9ee71e53e44877e14e0/tqdm-4.67.0.tar.gz", hash = "sha256:fe5a6f95e6fe0b9755e9469b77b9c3cf850048224ecaa8293d7d2d31f97d869a", size = 169739 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2b/78/57043611a16c655c8350b4c01b8d6abfb38cc2acb475238b62c2146186d7/tqdm-4.67.0-py3-none-any.whl", hash = "sha256:0cd8af9d56911acab92182e88d763100d4788bdf421d251616040cc4d44863be", size = 78590 },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
+]
+
+[[package]]
+name = "tzdata"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586 },
+]
+
+[[package]]
+name = "urllib3"
+version = "1.26.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e4/e8/6ff5e6bc22095cfc59b6ea711b687e2b7ed4bdb373f7eeec370a97d7392f/urllib3-1.26.20.tar.gz", hash = "sha256:40c2dc0c681e47eb8f90e7e27bf6ff7df2e677421fd46756da1161c39ca70d32", size = 307380 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/cf/8435d5a7159e2a9c83a95896ed596f68cf798005fe107cc655b5c5c14704/urllib3-1.26.20-py2.py3-none-any.whl", hash = "sha256:0ed14ccfbf1c30a9072c7ca157e4319b70d65f623e91e7b32fadb2853431016e", size = 144225 },
+]
+
+[[package]]
+name = "zipp"
+version = "3.20.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/54/bf/5c0000c44ebc80123ecbdddba1f5dcd94a5ada602a9c225d84b5aaa55e86/zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29", size = 24199 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/8b/5ba542fa83c90e09eac972fc9baca7a88e7e7ca4b221a89251954019308b/zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350", size = 9200 },
+]