From 4e8ca1c991ff00a801eeee191282746db2dc6869 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Kozlovsk=C3=BD?= <martin.kozlovsky@luxonis.com>
Date: Tue, 19 Dec 2023 18:24:04 +0100
Subject: [PATCH] Formatting and Style (#53)

* updated pre-commit hooks

* initial formatting

* fix typo

* style changes

* reverted
---
 .pre-commit-config.yaml                       |   27 +-
 README.md                                     |   14 +-
 examples/COCO_people_subset.ipynb             |  137 +-
 examples/test_emb_process.ipynb               |  224 +-
 examples/test_ldf_emb.ipynb                   | 1866 ++---------------
 examples/utils/data_utils.py                  |   21 +-
 src/luxonis_ml/data/augmentations.py          |   44 +-
 src/luxonis_ml/data/dataset.py                |  145 +-
 src/luxonis_ml/data/dataset_recognition.py    |    3 +-
 .../data/fiftyone_plugins/__init__.py         |   15 +-
 .../data/fiftyone_plugins/database.py         |    1 -
 src/luxonis_ml/data/loader.py                 |   21 +-
 src/luxonis_ml/data/utils/data_utils.py       |    8 +-
 src/luxonis_ml/data/utils/enums.py            |   18 +-
 src/luxonis_ml/data/utils/labelstudio.py      |    6 +-
 src/luxonis_ml/data/utils/parquet.py          |   17 +-
 src/luxonis_ml/embeddings/__init__.py         |   51 +-
 src/luxonis_ml/embeddings/methods/OOD.py      |   29 +-
 .../embeddings/methods/duplicate.py           |   23 +-
 src/luxonis_ml/embeddings/methods/mistakes.py |   22 +-
 .../embeddings/methods/representative.py      |   20 +-
 src/luxonis_ml/embeddings/requirements.txt    |    6 +-
 src/luxonis_ml/embeddings/utils/embedding.py  |   44 +-
 src/luxonis_ml/embeddings/utils/ldf.py        |   39 +-
 src/luxonis_ml/embeddings/utils/model.py      |   34 +-
 src/luxonis_ml/embeddings/utils/qdrant.py     |   41 +-
 src/luxonis_ml/enums/__init__.py              |    4 +-
 src/luxonis_ml/luxonis_ml.py                  |    8 +-
 src/luxonis_ml/scheme/v1/__init__.py          |    4 +-
 src/luxonis_ml/scheme/v1/archive_generator.py |   48 +-
 src/luxonis_ml/scheme/v1/config.py            |   10 +-
 .../v1/config_building_blocks/__init__.py     |   49 +-
 .../base_models/__init__.py                   |   31 +
 .../base_models/custom_base_model.py          |    3 +-
 .../base_models/head.py                       |   66 +-
 .../base_models/input.py                      |   20 +-
 .../base_models/metadata.py                   |   10 +-
 .../base_models/output.py                     |    9 +-
 .../config_building_blocks/enums/__init__.py  |   13 +-
 .../config_building_blocks/enums/data_type.py |    8 +-
 .../config_building_blocks/enums/decoding.py  |   11 +-
 .../enums/input_type.py                       |    8 +-
 .../config_building_blocks/enums/platform.py  |    8 +-
 src/luxonis_ml/scheme/v1/model.py             |    9 +-
 src/luxonis_ml/tracker/mlflow_plugins.py      |    1 -
 src/luxonis_ml/tracker/tracker.py             |   39 +-
 src/luxonis_ml/utils/config.py                |    8 +-
 src/luxonis_ml/utils/filesystem.py            |   31 +-
 src/luxonis_ml/utils/registry.py              |   11 +-
 tests/test_utils/test_config.py               |    1 +
 tests/test_utils/test_filesystem.py           |    3 -
 51 files changed, 890 insertions(+), 2399 deletions(-)
 create mode 100644 src/luxonis_ml/scheme/v1/config_building_blocks/base_models/__init__.py

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index ad9ab615..7507f1d1 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,11 +1,30 @@
 repos:
-  - repo: https://github.com/ambv/black
-    rev: 23.3.0
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.2
     hooks:
-    - id: black
-      language_version: python3.8
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+        types_or: [python, pyi, jupyter]
+      - id: ruff-format
+        types_or: [python, pyi, jupyter]
+
+  - repo: https://github.com/PyCQA/docformatter
+    rev: v1.7.5
+    hooks:
+      - id: docformatter
+        additional_dependencies: [tomli]
+        args: [--in-place]
+
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.4.0
     hooks:
     - id: no-commit-to-branch
       args: ['--branch', 'main', '--branch', 'dev']
+
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.10
+    hooks:
+      - id: mdformat
+        additional_dependencies:
+          - mdformat-gfm
+          - mdformat-toc
diff --git a/README.md b/README.md
index 3dc2c019..ffb3f44c 100644
--- a/README.md
+++ b/README.md
@@ -104,8 +104,8 @@ You could see that this configuration could also be used for any OAK-D-like prod
 
 Some more definitions:
 
-* `HType`\: The type of the component. Right now, there's really only `IMAGE`. But eventually, we will have video and point cloud.
-* `IType`\: For an image component, the type of the image. `BGR` is for any 3-channel image, `MONO` is for single-channel images, and `DEPTH` and `DISPARITY` can be uint16 single-channel images for subpixel disparity. The only difference between `DISPARITY` and `DEPTH` is a semantic difference.
+- `HType`: The type of the component. Right now, there's really only `IMAGE`. But eventually, we will have video and point cloud.
+- `IType`: For an image component, the type of the image. `BGR` is for any 3-channel image, `MONO` is for single-channel images, and `DEPTH` and `DISPARITY` can be uint16 single-channel images for subpixel disparity. The only difference between `DISPARITY` and `DEPTH` is a semantic difference.
 
 #### Adding Data
 
@@ -177,8 +177,8 @@ with LuxonisDataset(team_name, dataset_name) as dataset:
 
 The first element in the loaded tuple is the image(s) and the second is a dictionary where the keys may provide annotations in different formats.
 
-* `imgs` is (batch size x number of channels x height x width)
-* `dict['class']` is (batch size x number of classes)
-* `dict['bbox']` is (number of boxes in batch x 6 [image ID, class, x, y, width, height])
-* `dict['segmentation']` is (batch size x number of classes x height x width)
-* `dict['keypoints']` is (batch size x (number of points*2 + 1))
+- `imgs` is (batch size x number of channels x height x width)
+- `dict['class']` is (batch size x number of classes)
+- `dict['bbox']` is (number of boxes in batch x 6 \[image ID, class, x, y, width, height\])
+- `dict['segmentation']` is (batch size x number of classes x height x width)
+- `dict['keypoints']` is (batch size x (number of points\*2 + 1))
diff --git a/examples/COCO_people_subset.ipynb b/examples/COCO_people_subset.ipynb
index 81a5b3e3..4957009e 100644
--- a/examples/COCO_people_subset.ipynb
+++ b/examples/COCO_people_subset.ipynb
@@ -15,15 +15,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import glob, json, os\n",
+    "import glob\n",
+    "import json\n",
     "import numpy as np\n",
     "import cv2\n",
-    "from copy import deepcopy\n",
     "from tqdm import tqdm\n",
     "import matplotlib.pyplot as plt\n",
-    "from pycocotools import mask as mask_utils\n",
+    "import os\n",
+    "import zipfile\n",
+    "import gdown\n",
     "\n",
-    "from luxonis_ml.data import *\n",
+    "from luxonis_ml.data import LuxonisDataset, LuxonisLoader\n",
     "from luxonis_ml.enums import LabelType"
    ]
   },
@@ -59,9 +61,22 @@
    },
    "outputs": [],
    "source": [
-    "! pip install gdown\n",
-    "! gdown 1XlvFK7aRmt8op6-hHkWVKIJQeDtOwoRT -O ../data/COCO_people_subset.zip\n",
-    "! unzip ../data/COCO_people_subset.zip -d ../data/"
+    "url = \"https://drive.google.com/uc?id=1XlvFK7aRmt8op6-hHkWVKIJQeDtOwoRT\"\n",
+    "output_zip = \"../data/COCO_people_subset.zip\"\n",
+    "output_folder = \"../data/\"\n",
+    "\n",
+    "# Check if the data already exists\n",
+    "if not os.path.exists(output_zip) and not os.path.exists(\n",
+    "    os.path.join(output_folder, \"COCO_people_subset\")\n",
+    "):\n",
+    "    # Download the file\n",
+    "    gdown.download(url, output_zip, quiet=False)\n",
+    "\n",
+    "    # Unzip the file\n",
+    "    with zipfile.ZipFile(output_zip, \"r\") as zip_ref:\n",
+    "        zip_ref.extractall(output_folder)\n",
+    "else:\n",
+    "    print(\"Data already exists. Exiting.\")"
    ]
   },
   {
@@ -104,88 +119,86 @@
     "# splits = ['train' for _ in range(20)] + ['val' for _ in range(10)]\n",
     "\n",
     "def COCO_people_subset_generator():\n",
-    "\n",
     "    # find image paths and load COCO annotations\n",
-    "    img_dir = '../data/person_val2017_subset'\n",
-    "    annot_file = '../data/person_keypoints_val2017.json'\n",
+    "    img_dir = \"../data/person_val2017_subset\"\n",
+    "    annot_file = \"../data/person_keypoints_val2017.json\"\n",
     "    # get paths to images sorted by number\n",
-    "    im_paths = glob.glob(img_dir+'/*.jpg')\n",
-    "    nums = np.array([int(path.split('/')[-1].split('.')[0]) for path in im_paths])\n",
+    "    im_paths = glob.glob(img_dir + \"/*.jpg\")\n",
+    "    nums = np.array([int(path.split(\"/\")[-1].split(\".\")[0]) for path in im_paths])\n",
     "    idxs = np.argsort(nums)\n",
     "    im_paths = list(np.array(im_paths)[idxs])\n",
-    "    # load \n",
+    "    # load\n",
     "    with open(annot_file) as file:\n",
     "        data = json.load(file)\n",
-    "    imgs = data['images']\n",
-    "    anns = data['annotations']\n",
-    "    \n",
+    "    imgs = data[\"images\"]\n",
+    "    anns = data[\"annotations\"]\n",
+    "\n",
     "    for i, path in tqdm(enumerate(im_paths)):\n",
     "        # find annotations matching the COCO image\n",
-    "        gran = path.split('/')[-1]\n",
-    "        img = [img for img in imgs if img['file_name']==gran][0]\n",
-    "        img_id = img['id']\n",
-    "        img_anns = [ann for ann in anns if ann['image_id'] == img_id]\n",
-    "        \n",
+    "        gran = path.split(\"/\")[-1]\n",
+    "        img = [img for img in imgs if img[\"file_name\"] == gran][0]\n",
+    "        img_id = img[\"id\"]\n",
+    "        img_anns = [ann for ann in anns if ann[\"image_id\"] == img_id]\n",
+    "\n",
     "        # load the image\n",
     "        im = cv2.imread(path)\n",
     "        height, width, _ = im.shape\n",
-    "        \n",
-    "        # initialize annotations for LDF\n",
-    "        mask = np.zeros((height, width)) # segmentation mask is always a HxW numpy array\n",
-    "        boxes = [] # bounding boxes are a list of [class, x, y, width, height] of the box\n",
-    "        keypoints = [] # keypoints are a list of classes and (x,y) points\n",
-    "    \n",
+    "\n",
     "        if len(img_anns):\n",
     "            yield {\n",
     "                \"file\": path,\n",
     "                \"class\": \"person\",\n",
     "                \"type\": \"classification\",\n",
-    "                \"value\": True\n",
+    "                \"value\": True,\n",
     "            }\n",
-    "        \n",
+    "\n",
     "        for ann in img_anns:\n",
     "            # COCO-specific conversion for segmentation\n",
-    "            seg = ann['segmentation']\n",
-    "            if isinstance(seg, list): # polyline format\n",
+    "            seg = ann[\"segmentation\"]\n",
+    "            if isinstance(seg, list):  # polyline format\n",
     "                poly = []\n",
     "                for s in seg:\n",
-    "                    poly_arr = np.array(s).reshape(-1,2)\n",
-    "                    poly += [(poly_arr[i,0]/width, poly_arr[i,1]/height) for i in range(len(poly_arr))]\n",
+    "                    poly_arr = np.array(s).reshape(-1, 2)\n",
+    "                    poly += [\n",
+    "                        (poly_arr[i, 0] / width, poly_arr[i, 1] / height)\n",
+    "                        for i in range(len(poly_arr))\n",
+    "                    ]\n",
     "                yield {\n",
     "                    \"file\": path,\n",
     "                    \"class\": \"person\",\n",
     "                    \"type\": \"polyline\",\n",
-    "                    \"value\": poly\n",
+    "                    \"value\": poly,\n",
     "                }\n",
-    "            else: # RLE format\n",
+    "            else:  # RLE format\n",
     "                value = (seg[\"size\"][0], seg[\"size\"][1], seg[\"counts\"])\n",
     "                yield {\n",
     "                    \"file\": path,\n",
     "                    \"class\": \"person\",\n",
     "                    \"type\": \"segmentation\",\n",
-    "                    \"value\": value\n",
+    "                    \"value\": value,\n",
     "                }\n",
-    "                \n",
-    "            \n",
+    "\n",
     "            # COCO-specific conversion for bounding boxes\n",
-    "            x, y, w, h = ann['bbox']\n",
+    "            x, y, w, h = ann[\"bbox\"]\n",
     "            yield {\n",
     "                \"file\": path,\n",
     "                \"class\": \"person\",\n",
     "                \"type\": \"box\",\n",
-    "                \"value\": (x/width, y/height, w/width, h/height)\n",
+    "                \"value\": (x / width, y / height, w / width, h / height),\n",
     "            }\n",
-    "            \n",
+    "\n",
     "            # COCO-specific conversion for keypoints\n",
-    "            kps = np.array(ann['keypoints']).reshape(-1, 3)\n",
+    "            kps = np.array(ann[\"keypoints\"]).reshape(-1, 3)\n",
     "            keypoint = []\n",
     "            for kp in kps:\n",
-    "                keypoint.append((float(kp[0]/width), float(kp[1]/height), int(kp[2])))  \n",
+    "                keypoint.append(\n",
+    "                    (float(kp[0] / width), float(kp[1] / height), int(kp[2]))\n",
+    "                )\n",
     "            yield {\n",
     "                \"file\": path,\n",
     "                \"class\": \"person\",\n",
     "                \"type\": \"keypoints\",\n",
-    "                \"value\": keypoint\n",
+    "                \"value\": keypoint,\n",
     "            }"
    ]
   },
@@ -199,15 +212,17 @@
     "dataset = LuxonisDataset(dataset_name)\n",
     "dataset.set_classes([\"person\"])\n",
     "\n",
-    "annot_file = '../data/person_keypoints_val2017.json'\n",
+    "annot_file = \"../data/person_keypoints_val2017.json\"\n",
     "with open(annot_file) as file:\n",
     "    data = json.load(file)\n",
-    "dataset.set_skeletons({\n",
-    "    \"person\": {\n",
-    "        \"labels\": data[\"categories\"][0]['keypoints'],\n",
-    "        \"edges\": (np.array(data[\"categories\"][0][\"skeleton\"])-1).tolist()\n",
+    "dataset.set_skeletons(\n",
+    "    {\n",
+    "        \"person\": {\n",
+    "            \"labels\": data[\"categories\"][0][\"keypoints\"],\n",
+    "            \"edges\": (np.array(data[\"categories\"][0][\"skeleton\"]) - 1).tolist(),\n",
+    "        }\n",
     "    }\n",
-    "})\n",
+    ")\n",
     "dataset.add(COCO_people_subset_generator)"
    ]
   },
@@ -251,7 +266,7 @@
     "    box = ann[LabelType.BOUNDINGBOX]\n",
     "    seg = ann[LabelType.SEGMENTATION]\n",
     "    kps = ann[LabelType.KEYPOINT]\n",
-    "    \n",
+    "\n",
     "    # print(\"Sample classification tensor\")\n",
     "    # print(cls)\n",
     "    # print()\n",
@@ -270,19 +285,25 @@
     "\n",
     "    h, w, _ = image.shape\n",
     "    for b in box:\n",
-    "        cv2.rectangle(image, (int(b[1]*w),int(b[2]*h)), (int(b[1]*w+b[3]*w),int(b[2]*h+b[4]*h)), (255,0,0), 2)\n",
-    "    mask_viz = np.zeros((h,w,3)).astype(np.uint8)\n",
+    "        cv2.rectangle(\n",
+    "            image,\n",
+    "            (int(b[1] * w), int(b[2] * h)),\n",
+    "            (int(b[1] * w + b[3] * w), int(b[2] * h + b[4] * h)),\n",
+    "            (255, 0, 0),\n",
+    "            2,\n",
+    "        )\n",
+    "    mask_viz = np.zeros((h, w, 3)).astype(np.uint8)\n",
     "    for mask in seg:\n",
-    "        mask_viz[mask==1, 2] = 255\n",
+    "        mask_viz[mask == 1, 2] = 255\n",
     "    image = cv2.addWeighted(image, 0.5, mask_viz, 0.5, 0)\n",
     "\n",
     "    for kp in kps:\n",
-    "        kp = kp[1:].reshape(-1,3)\n",
+    "        kp = kp[1:].reshape(-1, 3)\n",
     "        for k in kp:\n",
-    "            cv2.circle(image, (int(k[0]*w),int(k[1]*h)), 2, (0,255,0), 2)\n",
-    "    \n",
+    "            cv2.circle(image, (int(k[0] * w), int(k[1] * h)), 2, (0, 255, 0), 2)\n",
+    "\n",
     "    plt.imshow(image)\n",
-    "    plt.axis('off')  # Optional: Hide axis\n",
+    "    plt.axis(\"off\")  # Optional: Hide axis\n",
     "    plt.show()\n",
     "    # break"
    ]
diff --git a/examples/test_emb_process.ipynb b/examples/test_emb_process.ipynb
index 3e427710..ee45ae41 100644
--- a/examples/test_emb_process.ipynb
+++ b/examples/test_emb_process.ipynb
@@ -10,26 +10,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/paperspace/Luxonis/lux-ml/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "\n",
-    "from luxonis_ml.embeddings.utils.qdrant import *\n",
+    "from luxonis_ml.embeddings.utils.qdrant import QdrantManager, QdrantAPI, Distance\n",
     "\n",
     "from luxonis_ml.embeddings.methods.mistakes import find_mismatches_centroids\n",
     "from luxonis_ml.embeddings.methods.OOD import leverage_OOD\n",
-    "from luxonis_ml.embeddings.methods.representative import calculate_similarity_matrix, find_representative_kmedoids\n",
+    "from luxonis_ml.embeddings.methods.representative import (\n",
+    "    calculate_similarity_matrix,\n",
+    "    find_representative_kmedoids,\n",
+    ")\n",
     "from luxonis_ml.embeddings.methods.duplicate import find_similar_qdrant\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
@@ -38,20 +32,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Container is already running.\n",
-      "Collection already exists\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "\n",
     "# Start Qdrant docker container\n",
     "QdrantManager(\"qdrant/qdrant\", \"qdrant_container2\").start_docker_qdrant()\n",
     "\n",
@@ -59,7 +43,7 @@
     "qdrant_api = QdrantAPI(\"localhost\", 6333, \"mnist3\")\n",
     "\n",
     "# Create a collection\n",
-    "qdrant_api.create_collection(vector_size=2048, distance=Distance.COSINE)\n"
+    "qdrant_api.create_collection(vector_size=2048, distance=Distance.COSINE)"
    ]
   },
   {
@@ -71,7 +55,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -80,7 +64,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -89,7 +73,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -98,7 +82,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -107,11 +91,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "desired_size = int(len(embeddings)*0.05)\n",
+    "desired_size = int(len(embeddings) * 0.05)\n",
     "# desired_size = 10\n",
     "selected_image_indices = find_representative_kmedoids(similarity_matrix, desired_size)\n",
     "# selected_image_indices = find_representative_greedy_qdrant(qdrant_client, desired_size, 0, \"mnist3\")"
@@ -119,7 +103,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -129,47 +113,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "320"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "represent_imgs = [p['image_path'] for p in payloads]\n",
+    "represent_imgs = [p[\"image_path\"] for p in payloads]\n",
     "len(represent_imgs)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 3000x1000 with 10 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# set plt size \n",
-    "plt.rcParams['figure.figsize'] = [30, 10]\n",
+    "# set plt size\n",
+    "plt.rcParams[\"figure.figsize\"] = [30, 10]\n",
     "\n",
-    "for j in range(min(10,len(represent_imgs))):\n",
-    "    plt.subplot(1,10,j+1)\n",
+    "for j in range(min(10, len(represent_imgs))):\n",
+    "    plt.subplot(1, 10, j + 1)\n",
     "    img = cv2.imread(represent_imgs[j])\n",
     "    plt.imshow(img)\n",
     "\n",
@@ -185,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -194,7 +156,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -204,34 +166,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "outlier_imgs = [p['image_path'] for p in payloads]"
+    "outlier_imgs = [p[\"image_path\"] for p in payloads]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 3000x1000 with 10 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "plt.rcParams['figure.figsize'] = [30, 10]\n",
+    "plt.rcParams[\"figure.figsize\"] = [30, 10]\n",
     "\n",
-    "for j in range(min(10,len(outlier_imgs))):\n",
-    "    plt.subplot(1,10,j+1)\n",
+    "for j in range(min(10, len(outlier_imgs))):\n",
+    "    plt.subplot(1, 10, j + 1)\n",
     "    img = cv2.imread(outlier_imgs[j])\n",
     "    plt.imshow(img)\n",
     "\n",
@@ -247,60 +198,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 3000x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "3 0.9878554618618619\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "i_sim, path_sim = find_similar_qdrant(ids[4], \n",
-    "                                      qdrant_api,\n",
-    "                                      dataset=\"\", \n",
-    "                                      k=100,\n",
-    "                                      n=100, \n",
-    "                                      method='first',\n",
-    "                                      k_method=\"kde_peaks\",\n",
-    "                                      kde_bw=\"scott\",\n",
-    "                                      plot=True)"
+    "i_sim, path_sim = find_similar_qdrant(\n",
+    "    ids[4],\n",
+    "    qdrant_api,\n",
+    "    dataset=\"\",\n",
+    "    k=100,\n",
+    "    n=100,\n",
+    "    method=\"first\",\n",
+    "    k_method=\"kde_peaks\",\n",
+    "    kde_bw=\"scott\",\n",
+    "    plot=True,\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 3000x1000 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "plt.rcParams['figure.figsize'] = [30, 10]\n",
+    "plt.rcParams[\"figure.figsize\"] = [30, 10]\n",
     "\n",
-    "for j in range(min(10,len(path_sim))):\n",
-    "    plt.subplot(1,10,j+1)\n",
+    "for j in range(min(10, len(path_sim))):\n",
+    "    plt.subplot(1, 10, j + 1)\n",
     "    img = cv2.imread(path_sim[j])\n",
     "    plt.imshow(img)\n",
     "\n",
@@ -316,7 +240,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -326,17 +250,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "X = np.array(embeddings)\n",
-    "y = np.array([p['class'] for p in payloads])"
+    "y = np.array([p[\"class\"] for p in payloads])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -345,36 +269,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# find img paths for misclassified images\n",
-    "mis_img_paths = [payloads[i]['image_path'] for i in mis_ix]"
+    "mis_img_paths = [payloads[i][\"image_path\"] for i in mis_ix]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 3000x1000 with 5 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# plot\n",
-    "plt.rcParams['figure.figsize'] = [30, 10]\n",
+    "plt.rcParams[\"figure.figsize\"] = [30, 10]\n",
     "\n",
-    "for j in range(min(5,len(mis_img_paths))):\n",
-    "    plt.subplot(1,10,j+1)\n",
+    "for j in range(min(5, len(mis_img_paths))):\n",
+    "    plt.subplot(1, 10, j + 1)\n",
     "    img = cv2.imread(mis_img_paths[j])\n",
     "    plt.title(f\"True: {y[mis_ix[j]]}, Pred: {new_y[j]}\")\n",
     "    plt.imshow(img)\n",
@@ -385,7 +298,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "lux-ml",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -399,10 +312,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
-  },
-  "orig_nbformat": 4
+   "version": "3.8.18"
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/examples/test_ldf_emb.ipynb b/examples/test_ldf_emb.ipynb
index a53061e5..877d7ea9 100644
--- a/examples/test_ldf_emb.ipynb
+++ b/examples/test_ldf_emb.ipynb
@@ -9,39 +9,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/paperspace/Luxonis/lux-ml/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
-    "import cv2\n",
     "import numpy as np\n",
     "\n",
+    "from matplotlib import pyplot as plt\n",
     "import torch\n",
     "import torch.onnx\n",
     "import onnx\n",
     "import onnxruntime\n",
+    "import torchvision\n",
     "\n",
-    "from qdrant_client import QdrantClient\n",
     "from qdrant_client.models import Distance\n",
     "\n",
-    "from luxonis_ml.data.dataset import HType, IType, LDFComponent, LuxonisDataset, BucketStorage\n",
+    "from luxonis_ml.data import (\n",
+    "    LuxonisDataset,\n",
+    "    LuxonisLoader,\n",
+    ")\n",
     "\n",
-    "from luxonis_ml.embeddings.utils.model import *\n",
-    "from luxonis_ml.embeddings.utils.embedding import *\n",
-    "from luxonis_ml.embeddings.utils.qdrant import *\n",
-    "from luxonis_ml.embeddings.utils.ldf import *\n",
+    "from luxonis_ml.embeddings.utils.model import (\n",
+    "    load_model_resnet50_minuslastlayer,\n",
+    "    export_model_onnx,\n",
+    "    load_model_onnx,\n",
+    "    extend_output_onnx,\n",
+    "    load_model,\n",
+    ")\n",
+    "from luxonis_ml.embeddings.utils.embedding import (\n",
+    "    extract_embeddings,\n",
+    "    extract_embeddings_onnx,\n",
+    "    save_embeddings,\n",
+    "    load_embeddings,\n",
+    ")\n",
+    "from luxonis_ml.embeddings.utils.qdrant import QdrantManager, QdrantAPI\n",
+    "from luxonis_ml.embeddings.utils.ldf import generate_embeddings\n",
     "\n",
-    "from utils.data_utils import *"
+    "from utils.data_utils import load_mnist_data"
    ]
   },
   {
@@ -53,138 +58,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./mnist/MNIST/raw/train-images-idx3-ubyte.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 9912422/9912422 [00:00<00:00, 233393088.68it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting ./mnist/MNIST/raw/train-images-idx3-ubyte.gz to ./mnist/MNIST/raw\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./mnist/MNIST/raw/train-labels-idx1-ubyte.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 28881/28881 [00:00<00:00, 94933929.33it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting ./mnist/MNIST/raw/train-labels-idx1-ubyte.gz to ./mnist/MNIST/raw\n",
-      "\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./mnist/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 1648877/1648877 [00:00<00:00, 160305303.34it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting ./mnist/MNIST/raw/t10k-images-idx3-ubyte.gz to ./mnist/MNIST/raw\n",
-      "\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 4542/4542 [00:00<00:00, 11817945.89it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting ./mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./mnist/MNIST/raw\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Load the data\n",
-    "data_loader = load_mnist_data(save_path='./mnist', num_samples=640, batch_size=64)"
+    "data_loader = load_mnist_data(save_path=\"./mnist\", num_samples=640, batch_size=64)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# Load the model\n",
     "model = load_model_resnet50_minuslastlayer()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# Extract embeddings from the dataset\n",
     "embeddings, labels = extract_embeddings(model, data_loader)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "save_embeddings(embeddings, labels)"
    ]
   },
@@ -197,17 +104,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Load the data\n",
-    "data_loader = load_mnist_data(save_path='./mnist', num_samples=640, batch_size=64)"
+    "data_loader = load_mnist_data(save_path=\"./mnist\", num_samples=640, batch_size=64)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -221,7 +128,9 @@
     "onnx_model = load_model_onnx(model_path=\"resnet50.onnx\")\n",
     "\n",
     "# Extend the ONNX model with an intermediate output layer\n",
-    "onnx_model = extend_output_onnx(onnx_model, intermediate_tensor_name=\"/Flatten_output_0\")\n",
+    "onnx_model = extend_output_onnx(\n",
+    "    onnx_model, intermediate_tensor_name=\"/Flatten_output_0\"\n",
+    ")\n",
     "\n",
     "# Save the ONNX model\n",
     "onnx.save(onnx_model, \"resnet50-1.onnx\")"
@@ -229,16 +138,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Create an ONNX Runtime session\n",
-    "provider = ['CUDAExecutionProvider'] if torch.cuda.is_available() and 'CUDAExecutionProvider' in onnxruntime.get_available_providers() else None\n",
+    "provider = (\n",
+    "    [\"CUDAExecutionProvider\"]\n",
+    "    if torch.cuda.is_available()\n",
+    "    and \"CUDAExecutionProvider\" in onnxruntime.get_available_providers()\n",
+    "    else None\n",
+    ")\n",
     "ort_session = onnxruntime.InferenceSession(\"resnet50-1.onnx\", providers=provider)\n",
     "\n",
     "# Extract embeddings from the dataset\n",
-    "embeddings, labels = extract_embeddings_onnx(ort_session, data_loader, \"/Flatten_output_0\")\n",
+    "embeddings, labels = extract_embeddings_onnx(\n",
+    "    ort_session, data_loader, \"/Flatten_output_0\"\n",
+    ")\n",
     "\n",
     "# Save the embeddings and labels to a file\n",
     "save_embeddings(embeddings, labels)"
@@ -246,7 +162,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -255,17 +171,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Container is already running.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Start Qdrant docker container\n",
     "QdrantManager(\"qdrant/qdrant\", \"qdrant_container2\").start_docker_qdrant()"
@@ -273,7 +181,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -283,36 +191,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Created new collection\n",
-      "Inserted 50 new embeddings for batch 0-50\n",
-      "Inserted 50 new embeddings for batch 50-100\n",
-      "Inserted 50 new embeddings for batch 100-150\n",
-      "Inserted 50 new embeddings for batch 150-200\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Inserted 50 new embeddings for batch 200-250\n",
-      "Inserted 50 new embeddings for batch 250-300\n",
-      "Inserted 50 new embeddings for batch 300-350\n",
-      "Inserted 50 new embeddings for batch 350-400\n",
-      "Inserted 50 new embeddings for batch 400-450\n",
-      "Inserted 50 new embeddings for batch 450-500\n",
-      "Inserted 50 new embeddings for batch 500-550\n",
-      "Inserted 50 new embeddings for batch 550-600\n",
-      "Inserted 40 new embeddings for batch 600-640\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Create a collection\n",
     "vector_size = embeddings.shape[1]\n",
@@ -326,21 +207,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ScoredPoint(id=1, version=0, score=0.9999999, payload={'label': 6}, vector=None)\n",
-      " ScoredPoint(id=246, version=4, score=0.94871294, payload={'label': 6}, vector=None)\n",
-      " ScoredPoint(id=281, version=5, score=0.9470429, payload={'label': 6}, vector=None)\n",
-      " ScoredPoint(id=220, version=4, score=0.9374444, payload={'label': 6}, vector=None)\n",
-      " ScoredPoint(id=602, version=12, score=0.9349781, payload={'label': 6}, vector=None)]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Search for the nearest neighbors\n",
     "search_results = qdrant_api.search_embeddings(embeddings[0], top=5)\n",
@@ -358,296 +227,169 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "def train_test_val_split(NUM_SAMPLES, train=0.8, val=0.1, test=0.1, seed=42):\n",
     "    if train + val + test != 1.0:\n",
     "        raise ValueError(\"TRAIN + VAL + TEST must equal 1.0\")\n",
-    "    \n",
+    "\n",
     "    np.random.seed(seed)\n",
     "    # generate random indices for train, val, test splits\n",
     "    indices = np.random.permutation(NUM_SAMPLES)\n",
-    "    train_indices, val_indices, test_indices = indices[:int(train * NUM_SAMPLES)], indices[int(train * NUM_SAMPLES):int((train + val) * NUM_SAMPLES)], indices[int((train + val) * NUM_SAMPLES):]\n",
-    "    train_test_val = np.array([\"train\"]*NUM_SAMPLES)\n",
+    "    train_indices, val_indices, test_indices = (\n",
+    "        indices[: int(train * NUM_SAMPLES)],\n",
+    "        indices[int(train * NUM_SAMPLES) : int((train + val) * NUM_SAMPLES)],\n",
+    "        indices[int((train + val) * NUM_SAMPLES) :],\n",
+    "    )\n",
+    "    train_test_val = np.array([\"train\"] * NUM_SAMPLES)\n",
     "    train_test_val[train_indices] = \"train\"\n",
     "    train_test_val[val_indices] = \"val\"\n",
     "    train_test_val[test_indices] = \"test\"\n",
     "\n",
-    "    return train_test_val\n"
+    "    return train_test_val"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "BUCKET_STORAGE = BucketStorage.LOCAL\n",
-    "NUM_SAMPLES = 6400 #-1 # minus one is equivalent to all samples\n",
+    "NUM_SAMPLES = 6400  # -1 # minus one is equivalent to all samples\n",
     "BATCH_SIZE = 64\n",
-    "TRAIN,VAL,TEST = 0.8,0.1,0.1"
+    "TRAIN, VAL, TEST = 0.8, 0.1, 0.1"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of samples: 6400\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "\n",
     "# Load the MNIST data\n",
-    "data_loader = load_mnist_data(save_path='./mnist', num_samples=NUM_SAMPLES, batch_size=BATCH_SIZE)\n",
+    "data_loader = load_mnist_data(\n",
+    "    save_path=\"./mnist\", num_samples=NUM_SAMPLES, batch_size=BATCH_SIZE\n",
+    ")\n",
     "NUM_SAMPLES = len(data_loader.dataset)\n",
-    "print(f\"Number of samples: {NUM_SAMPLES}\")\n"
+    "print(f\"Number of samples: {NUM_SAMPLES}\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# Split the data into train, val, test\n",
-    "train_test_val = train_test_val_split(NUM_SAMPLES, train=TRAIN, val=VAL, test=TEST)\n"
+    "train_test_val = train_test_val_split(NUM_SAMPLES, train=TRAIN, val=VAL, test=TEST)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Create a tmp directory to store the images\n",
-    "mnist_image_dir = './mnist_images'\n",
+    "mnist_image_dir = \"./mnist_images\"\n",
     "if not os.path.exists(mnist_image_dir):\n",
-    "    os.makedirs(mnist_image_dir)\n"
+    "    os.makedirs(mnist_image_dir)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# Convert MNIST data to Luxonis ML format\n",
-    "additions = []\n",
-    "batch_num = 0\n",
-    "for batch in data_loader:\n",
-    "    images, labels = batch\n",
-    "    for i, (image, label) in enumerate(zip(images, labels)):\n",
-    "        img_ix = batch_num*BATCH_SIZE + i\n",
-    "        \n",
-    "        # Save image to disk\n",
-    "        image_path = os.path.join(mnist_image_dir, f\"mnist_{img_ix}.jpg\")\n",
-    "        torchvision.utils.save_image(image, image_path)\n",
-    "        \n",
-    "        # Create dictionary structure for Luxonis ML\n",
-    "        additions.append({\n",
-    "            'image': {\n",
-    "                'filepath': image_path,\n",
-    "                'split': train_test_val[img_ix],\n",
-    "                'class': str(label.item())\n",
+    "\n",
+    "def mnist_LDF_generator():\n",
+    "    batch_num = 0\n",
+    "    for batch in data_loader:\n",
+    "        images, labels = batch\n",
+    "        for i, (image, label) in enumerate(zip(images, labels)):\n",
+    "            img_ix = batch_num * BATCH_SIZE + i\n",
+    "\n",
+    "            # Save image to disk\n",
+    "            image_path = os.path.join(mnist_image_dir, f\"mnist_{img_ix}.jpg\")\n",
+    "            torchvision.utils.save_image(image, image_path)\n",
+    "\n",
+    "            # Create dictionary structure for Luxonis ML\n",
+    "            yield {\n",
+    "                \"file\": image_path,\n",
+    "                \"class\": str(label.item()),\n",
+    "                \"type\": \"classification\",\n",
+    "                \"value\": True,\n",
     "            }\n",
-    "        })\n",
-    "    batch_num += 1\n",
+    "        batch_num += 1\n",
+    "\n",
     "\n",
-    "# original_additions = deepcopy(additions)\n"
+    "# original_additions = deepcopy(additions)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dataset ID: 64e7566cca1096d3483cb822\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "\n",
     "# 2. Load the MNIST Data into LDF\n",
-    "team_id = \"luxonis_id\"\n",
-    "team_name = \"luxonis_team\"\n",
     "dataset_name = \"mnist_dataset\"\n",
     "\n",
     "# Create a new dataset in LDF\n",
-    "dataset_id = LuxonisDataset.create(\n",
-    "    team_id=team_id,\n",
-    "    team_name=team_name,\n",
-    "    dataset_name=dataset_name\n",
-    ")\n",
-    "\n",
-    "print(f\"Dataset ID: {dataset_id}\")\n"
+    "dataset = LuxonisDataset(dataset_name)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:40:12,482 [WARNING] Updating from a previously saved source!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:40:14,412 [INFO] Checking for additions or modifications...\n",
-      "100%|██████████| 6400/6400 [00:21<00:00, 303.91it/s]\n",
-      "2023-09-04 16:40:35,477 [INFO] Extracting dataset media...\n",
-      "100%|██████████| 6400/6400 [11:59<00:00,  8.90it/s]\n",
-      "2023-09-04 16:52:34,538 [INFO] Executing changes to dataset...\n",
-      "100%|██████████| 2163/2163 [00:07<00:00, 301.51it/s]\n",
-      "2023-09-04 16:52:42,058 [INFO] Creating new version...\n",
-      "100%|██████████| 2163/2163 [01:38<00:00, 21.93it/s]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "\n",
     "# Add the MNIST data to the dataset\n",
-    "with LuxonisDataset(\n",
-    "    team_id=team_id,\n",
-    "    dataset_id=dataset_id,\n",
-    "    team_name=team_name,\n",
-    "    dataset_name=dataset_name,\n",
-    "    bucket_storage=BUCKET_STORAGE\n",
-    ") as dataset:\n",
-    "    dataset.create_source(\n",
-    "        'mnist',\n",
-    "        custom_components=[\n",
-    "            LDFComponent('image', HType.IMAGE, IType.BGR)\n",
-    "        ]\n",
-    "    )\n",
-    "    dataset.set_classes(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])\n",
-    "    dataset.add(additions)\n",
-    "    dataset.create_version(note=\"Adding MNIST data\")\n"
+    "\n",
+    "dataset.set_classes([\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"])\n",
+    "dataset.add(mnist_LDF_generator)\n",
+    "dataset.make_splits()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<Sample: {\n",
-      "    'id': '64e758bbca1096d3483d0327',\n",
-      "    'media_type': 'image',\n",
-      "    'filepath': '/luxonis_id/datasets/64e7566cca1096d3483cb822/image/b1e7fbba-46bb-5050-b4f6-f84d41fe4e8f.jpg',\n",
-      "    'tags': [],\n",
-      "    'metadata': None,\n",
-      "    'mnist': <Group: {'id': '64e756a6ca1096d3483cb826', 'name': 'image'}>,\n",
-      "    'version': 1.0,\n",
-      "    'latest': False,\n",
-      "    'split': 'train',\n",
-      "    'class': <Classifications: {\n",
-      "        'classifications': [\n",
-      "            <Classification: {\n",
-      "                'id': '64e758b7ca1096d3483cea27',\n",
-      "                'tags': [],\n",
-      "                'label': '5',\n",
-      "                'confidence': None,\n",
-      "                'logits': None,\n",
-      "            }>,\n",
-      "        ],\n",
-      "        'logits': None,\n",
-      "    }>,\n",
-      "    'instance_id': 'b1e7fbba-46bb-5050-b4f6-f84d41fe4e8f',\n",
-      "    'tid': '64e756a6ca1096d3483cb827',\n",
-      "}>\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "from matplotlib import pyplot as plt\n",
-    "\n",
-    "with LuxonisDataset(    \n",
-    "    team_id=team_id,\n",
-    "    dataset_id=dataset_id\n",
-    ") as dataset:\n",
-    "    \n",
-    "    for sample in dataset.fo_dataset:\n",
-    "        # img_path = f\"{str(Path.home())}/.cache/luxonis_ml/data/{sample.filepath}\"\n",
-    "        print(sample)\n",
-    "        id_sub = dataset.path.split('/')[-1]\n",
-    "        img_rel_path = sample.filepath.split(id_sub)[-1]\n",
-    "        img_path = dataset.path + img_rel_path\n",
-    "\n",
-    "        img = cv2.imread(img_path)\n",
-    "        plt.imshow(img)\n",
-    "        plt.show()\n",
-    "        break\n",
-    "    "
+    "loader = LuxonisLoader(dataset)\n",
+    "for img, _ in loader:\n",
+    "    plt.imshow(img)\n",
+    "    plt.show()\n",
+    "    break"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# Initialize the ONNX Runtime session for the model\n",
-    "provider = ['CUDAExecutionProvider'] if torch.cuda.is_available() and 'CUDAExecutionProvider' in onnxruntime.get_available_providers() else None\n",
-    "ort_session = onnxruntime.InferenceSession(\"resnet50-1.onnx\", providers=provider)\n"
+    "provider = (\n",
+    "    [\"CUDAExecutionProvider\"]\n",
+    "    if torch.cuda.is_available()\n",
+    "    and \"CUDAExecutionProvider\" in onnxruntime.get_available_providers()\n",
+    "    else None\n",
+    ")\n",
+    "ort_session = onnxruntime.InferenceSession(\"resnet50-1.onnx\", providers=provider)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:54:21,584 [INFO] HTTP Request: GET http://localhost:6333/collections/mnist3 \"HTTP/1.1 404 Not Found\"\n",
-      "2023-09-04 16:54:21,586 [INFO] HTTP Request: DELETE http://localhost:6333/collections/mnist3 \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:54:21,672 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3 \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Container is already running.\n",
-      "Created new collection\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Start Qdrant docker container\n",
     "QdrantManager(\"qdrant/qdrant\", \"qdrant_container2\").start_docker_qdrant()\n",
@@ -661,1340 +403,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:54:27,264 [INFO] HTTP Request: POST http://localhost:6333/collections/mnist3/points \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,282 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,324 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,370 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,414 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,458 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 1 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 2 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 3 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 4 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 5 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:13,501 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,543 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,584 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,625 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,664 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,702 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 6 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 7 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 8 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 9 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 10 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 11 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:13,741 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,783 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,824 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,870 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,910 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:13,953 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 12 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 13 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 14 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 15 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 16 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 17 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:13,995 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,034 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,076 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,118 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,154 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,195 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 18 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 19 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 20 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 21 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 22 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 23 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:14,237 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,349 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,388 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,423 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 24 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 25 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 26 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 27 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:14,466 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,509 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,547 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,584 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,623 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,665 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 28 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 29 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 30 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 31 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 32 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 33 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:14,704 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,742 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,781 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,819 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,858 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,894 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 34 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 35 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 36 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 37 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 38 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 39 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:14,934 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:14,976 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,017 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,057 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,100 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 40 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 41 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 42 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 43 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 44 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:15,143 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,181 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,221 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,261 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,302 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,343 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 45 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 46 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 47 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 48 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 49 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 50 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:15,382 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,421 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,457 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,504 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,545 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,588 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 51 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 52 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 53 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 54 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 55 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 56 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:15,629 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,667 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,712 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,751 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,791 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,829 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 57 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 58 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 59 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 60 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 61 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 62 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:15,866 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,907 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,945 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:15,984 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,035 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,075 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 63 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 64 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 65 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 66 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 67 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 68 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:16,113 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,155 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,193 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,231 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,271 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,315 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 69 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 70 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 71 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 72 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 73 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 74 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:16,353 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,393 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,430 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,470 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,507 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,546 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 75 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 76 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 77 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 78 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 79 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 80 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:16,588 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,625 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,663 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,710 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,748 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,796 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 81 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 82 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 83 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 84 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 85 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 86 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:16,838 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,875 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,919 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,959 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:16,996 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,034 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 87 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 88 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 89 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 90 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 91 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 92 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:17,074 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,125 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,163 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,211 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,252 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,291 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 93 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 94 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 95 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 96 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 97 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 98 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:17,330 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,371 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,412 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,456 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,503 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,542 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 99 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 100 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 101 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 102 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 103 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 104 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:17,584 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,623 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,661 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,704 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,744 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,785 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 105 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 106 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 107 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 108 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 109 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 110 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:17,826 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,865 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,905 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,944 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:17,984 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,023 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 111 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 112 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 113 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 114 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 115 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 116 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:18,063 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,102 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,141 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,181 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,222 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,263 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 117 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 118 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 119 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 120 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 121 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 122 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:18,310 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,349 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,388 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,428 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,468 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,506 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 123 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 124 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 125 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 126 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 127 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 128 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:18,548 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,592 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,634 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,673 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,717 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 129 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 130 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 131 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 132 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 133 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:18,758 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,797 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,838 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,879 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,920 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:18,957 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 134 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 135 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 136 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 137 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 138 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 139 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:18,996 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,039 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,077 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,117 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,156 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,197 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 140 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 141 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 142 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 143 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 144 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 145 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:19,237 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,277 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,316 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,357 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,398 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,437 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 146 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 147 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 148 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 149 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 150 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 151 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:19,476 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,519 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,558 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,596 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,636 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,679 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 152 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 153 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 154 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 155 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 156 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 157 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:19,718 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,762 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,806 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,846 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,886 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 158 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 159 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 160 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 161 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 162 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:19,927 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:19,966 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,004 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,046 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,085 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,124 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 163 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 164 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 165 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 166 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 167 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 168 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:20,165 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,204 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,245 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,290 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,330 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 169 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 170 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 171 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 172 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 173 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:20,375 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,418 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,457 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,497 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,539 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,578 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 174 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 175 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 176 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 177 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 178 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 179 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:20,619 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,661 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,701 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,741 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,786 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,824 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 180 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 181 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 182 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 183 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 184 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 185 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:20,862 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,901 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,940 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:20,978 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,023 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,061 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 186 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 187 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 188 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 189 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 190 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 191 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:21,102 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,145 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,189 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,229 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,270 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,310 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 192 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 193 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 194 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 195 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 196 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:21,354 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,396 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,436 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,485 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,528 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 197 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 198 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 199 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 200 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 201 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 202 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:21,570 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,611 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,655 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,701 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,743 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 203 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 204 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 205 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 206 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 207 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:21,786 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,836 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,877 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,919 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:21,957 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 208 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 209 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 210 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 211 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 212 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:21,997 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,039 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,078 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,119 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,162 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,205 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 213 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 214 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 215 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 216 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 217 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 218 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:22,246 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,283 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,321 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,359 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,399 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,437 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 219 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 220 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 221 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 222 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 223 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 224 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:22,478 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,518 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,559 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,598 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,637 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,682 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 225 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 226 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 227 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 228 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 229 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 230 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:22,727 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,766 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,805 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,848 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,891 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:22,932 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 231 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 232 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 233 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 234 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 235 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 236 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:22,976 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,021 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,062 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,103 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,143 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,183 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 237 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 238 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 239 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 240 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 241 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 242 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:23,224 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,263 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,304 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,343 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,384 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,422 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 243 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 244 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 245 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 246 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 247 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 248 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:23,461 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,505 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,545 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,585 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,624 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 249 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 250 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 251 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 252 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 253 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:23,665 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,705 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,748 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,791 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,830 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,867 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 254 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 255 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 256 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 257 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 258 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 259 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:23,905 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,944 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:23,985 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,026 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,064 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,103 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 260 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 261 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 262 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 263 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 264 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 265 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:24,143 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,187 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,228 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,271 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,313 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 266 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 267 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 268 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 269 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 270 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:24,359 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,399 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,441 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,479 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,520 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,561 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 271 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 272 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 273 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 274 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 275 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 276 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:24,600 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,641 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,681 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,721 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,763 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,800 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 277 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 278 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 279 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 280 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 281 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 282 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:24,837 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,875 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,916 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,956 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:24,994 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,034 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 283 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 284 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 285 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 286 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 287 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 288 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:25,078 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,116 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,154 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,198 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,238 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,280 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 289 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 290 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 291 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 292 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 293 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 294 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:25,319 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,358 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,402 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,442 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,480 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,521 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 295 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 296 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 297 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 298 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 299 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 300 / 303 of size 64 to Qdrant.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:25,567 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,607 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n",
-      "2023-09-04 16:55:25,638 [INFO] HTTP Request: PUT http://localhost:6333/collections/mnist3/points?wait=true \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upserted batch 301 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 302 / 303 of size 64 to Qdrant.\n",
-      "Upserted batch 303 / 303 of size 51 to Qdrant.\n",
-      "Embeddings generation and insertion completed!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "\n",
     "# Load the LuxonisDataset\n",
-    "with LuxonisDataset(team_id=team_id, dataset_id=dataset_id) as dataset:\n",
-    "    # Call the _generate_embeddings method\n",
-    "    emb_dict = generate_embeddings(dataset, ort_session, qdrant_api, output_layer_name=\"/Flatten_output_0\")\n"
+    "emb_dict = generate_embeddings(\n",
+    "    dataset, ort_session, qdrant_api, output_layer_name=\"/Flatten_output_0\"\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<Sample: {\n",
-      "    'id': '64e758bbca1096d3483d0327',\n",
-      "    'media_type': 'image',\n",
-      "    'filepath': '/luxonis_id/datasets/64e7566cca1096d3483cb822/image/b1e7fbba-46bb-5050-b4f6-f84d41fe4e8f.jpg',\n",
-      "    'tags': [],\n",
-      "    'metadata': None,\n",
-      "    'mnist': <Group: {'id': '64e756a6ca1096d3483cb826', 'name': 'image'}>,\n",
-      "    'version': 1.0,\n",
-      "    'latest': False,\n",
-      "    'split': 'train',\n",
-      "    'class': <Classifications: {\n",
-      "        'classifications': [\n",
-      "            <Classification: {\n",
-      "                'id': '64e758b7ca1096d3483cea27',\n",
-      "                'tags': [],\n",
-      "                'label': '5',\n",
-      "                'confidence': None,\n",
-      "                'logits': None,\n",
-      "            }>,\n",
-      "        ],\n",
-      "        'logits': None,\n",
-      "    }>,\n",
-      "    'instance_id': 'b1e7fbba-46bb-5050-b4f6-f84d41fe4e8f',\n",
-      "    'tid': '64e756a6ca1096d3483cb827',\n",
-      "}>\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "first_emb = None\n",
     "\n",
-    "with LuxonisDataset(    \n",
-    "    team_id=team_id,\n",
-    "    dataset_id=dataset_id\n",
-    ") as dataset:\n",
-    "    # get a specific sample from dataset\n",
-    "    first_sample = list(emb_dict.keys())[0]\n",
-    "    first_emb = emb_dict[first_sample]\n",
-    "    sample_id = first_sample\n",
-    "    \n",
-    "    # sample_id = '64e758bdca1096d3483d18f4'\n",
-    "    sample = dataset.fo_dataset[sample_id]\n",
-    "    print(sample)"
+    "# get a specific sample from dataset\n",
+    "first_sample = list(emb_dict.keys())[0]\n",
+    "first_emb = emb_dict[first_sample]\n",
+    "sample_id = first_sample\n",
+    "\n",
+    "# sample_id = '64e758bdca1096d3483d18f4'\n",
+    "sample = dataset.fo_dataset[sample_id]\n",
+    "print(sample)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-09-04 16:55:25,695 [INFO] HTTP Request: POST http://localhost:6333/collections/mnist3/points/search \"HTTP/1.1 200 OK\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ScoredPoint(id='b1e7fbba-46bb-5050-b4f6-f84d41fe4e8f', version=186, score=1.0, payload={'class': '5', 'image_path': '/home/paperspace/.cache/luxonis_ml/data/luxonis_id/datasets/64e7566cca1096d3483cb822/image/b1e7fbba-46bb-5050-b4f6-f84d41fe4e8f.jpg', 'instance_id': 'b1e7fbba-46bb-5050-b4f6-f84d41fe4e8f', 'sample_id': '64f1c388a920f57c06d436b7', 'split': 'train'}, vector=None)\n",
-      " ScoredPoint(id='0594bd6b-31be-5326-b791-fc7be96fb9f6', version=205, score=0.9746066, payload={'class': '5', 'image_path': '/home/paperspace/.cache/luxonis_ml/data/luxonis_id/datasets/64e7566cca1096d3483cb822/image/0594bd6b-31be-5326-b791-fc7be96fb9f6.jpg', 'instance_id': '0594bd6b-31be-5326-b791-fc7be96fb9f6', 'sample_id': '64f5f854176f1a427e034eb4', 'split': 'train'}, vector=None)\n",
-      " ScoredPoint(id='f3f1c59d-1f5f-5e0f-832e-caa0411d2e55', version=52, score=0.9745133, payload={'class': '5', 'image_path': '/home/paperspace/.cache/luxonis_ml/data/luxonis_id/datasets/64e7566cca1096d3483cb822/image/f3f1c59d-1f5f-5e0f-832e-caa0411d2e55.jpg', 'instance_id': 'f3f1c59d-1f5f-5e0f-832e-caa0411d2e55', 'sample_id': '64e758bcca1096d3483d104d', 'split': 'train'}, vector=None)\n",
-      " ScoredPoint(id='fc9b9fa0-4229-5545-ad3c-f68a67e38132', version=276, score=0.9693118, payload={'class': '9', 'image_path': '/home/paperspace/.cache/luxonis_ml/data/luxonis_id/datasets/64e7566cca1096d3483cb822/image/fc9b9fa0-4229-5545-ad3c-f68a67e38132.jpg', 'instance_id': 'fc9b9fa0-4229-5545-ad3c-f68a67e38132', 'sample_id': '64f60b540217a88784aef127', 'split': 'test'}, vector=None)\n",
-      " ScoredPoint(id='a6431178-9078-5075-ace0-32709dbfbe1f', version=52, score=0.96916306, payload={'class': '5', 'image_path': '/home/paperspace/.cache/luxonis_ml/data/luxonis_id/datasets/64e7566cca1096d3483cb822/image/a6431178-9078-5075-ace0-32709dbfbe1f.jpg', 'instance_id': 'a6431178-9078-5075-ace0-32709dbfbe1f', 'sample_id': '64e758bcca1096d3483d105d', 'split': 'train'}, vector=None)]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Search for the nearest neighbors\n",
     "search_results = qdrant_api.search_embeddings(np.array(first_emb), top=5)\n",
@@ -2010,7 +451,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2026,7 +467,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2047,23 +488,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# # Delete the Luxonis ML dataset\n",
-    "# with LuxonisDataset(\n",
-    "#     team_id=team_id,\n",
-    "#     dataset_id=dataset_id,\n",
-    "# ) as dataset:\n",
-    "    \n",
-    "#     dataset.delete_dataset()"
+    "\n",
+    "# dataset.delete_dataset()"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "lux-ml",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -2077,10 +514,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
-  },
-  "orig_nbformat": 4
+   "version": "3.8.18"
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/examples/utils/data_utils.py b/examples/utils/data_utils.py
index c84e560f..f567cfa9 100644
--- a/examples/utils/data_utils.py
+++ b/examples/utils/data_utils.py
@@ -1,8 +1,7 @@
-"""
-MNIST Dataset Loader with Custom Preprocessing
+"""MNIST Dataset Loader with Custom Preprocessing.
 
-This module provides utility functions to load the MNIST dataset with specific 
-transformations applied. The dataset is transformed to be compatible with models 
+This module provides utility functions to load the MNIST dataset with specific
+transformations applied. The dataset is transformed to be compatible with models
 that expect 3-channel RGB images, such as models pre-trained on the ImageNet dataset.
 
 The main transformations applied are:
@@ -14,7 +13,7 @@
 
 Functions:
     - `mnist_transformations()`: Returns the composed transformations.
-    - `load_mnist_data(save_path='./mnist', num_samples=640, batch_size=64)`: Loads MNIST data with the defined transformations 
+    - `load_mnist_data(save_path='./mnist', num_samples=640, batch_size=64)`: Loads MNIST data with the defined transformations
         and returns a DataLoader. It provides options to specify the number of samples and batch size.
 
 Example usage:
@@ -25,7 +24,7 @@
         ...  # Your processing here
     ```
 
-Note: This loader is particularly useful when you want to use MNIST data with models that were 
+Note: This loader is particularly useful when you want to use MNIST data with models that were
 pre-trained on datasets like ImageNet and expect 3-channel RGB input.
 """
 
@@ -36,9 +35,10 @@
 
 
 def mnist_transformations():
-    """
-    Returns composed transformations for the MNIST dataset.
-    Transforms the images from 1 channel grayscale to 3 channels RGB and resizes them.
+    """Returns composed transformations for the MNIST dataset.
+
+    Transforms the images from 1 channel grayscale to 3 channels RGB and
+    resizes them.
     """
     return transforms.Compose(
         [
@@ -52,8 +52,7 @@ def mnist_transformations():
 
 
 def load_mnist_data(save_path="./mnist", num_samples=640, batch_size=64):
-    """
-    Loads the MNIST dataset with the specified preprocessing.
+    """Loads the MNIST dataset with the specified preprocessing.
 
     Parameters:
     - save_path (str): Directory to save/load the MNIST data.
diff --git a/src/luxonis_ml/data/augmentations.py b/src/luxonis_ml/data/augmentations.py
index e6d1cd1e..8269763c 100644
--- a/src/luxonis_ml/data/augmentations.py
+++ b/src/luxonis_ml/data/augmentations.py
@@ -7,13 +7,20 @@
 from .loader import LabelType
 from luxonis_ml.utils.registry import Registry
 
+from albumentations.core.transforms_interface import (
+    BoxInternalType,
+    DualTransform,
+    KeypointInternalType,
+)
+from albumentations.core.bbox_utils import denormalize_bbox, normalize_bbox
+
 
 AUGMENTATIONS = Registry(name="augmentations")
 
 
 class Augmentations:
     def __init__(self, train_rgb: bool = True):
-        """Base class for augmentations that are used in LuxonisLoader
+        """Base class for augmentations that are used in LuxonisLoader.
 
         Args:
             train_rgb (bool, optional): Whether should use RGB or BGR images. Defaults to True.
@@ -30,7 +37,8 @@ def _parse_cfg(
         augmentations: List[Dict[str, Any]],
         keep_aspect_ratio: bool = True,
     ) -> Tuple[A.BatchCompose, A.Compose]:
-        """Parses provided config and returns Albumentations BatchedCompose object and Compose object for default transforms
+        """Parses provided config and returns Albumentations BatchedCompose
+        object and Compose object for default transforms.
 
         Args:
             image_size (List[int]): Desired image size [H,W]
@@ -102,7 +110,7 @@ def __call__(
         ns: int = 1,
         nk: int = 1,
     ) -> Tuple[np.ndarray, Dict[LabelType, np.ndarray]]:
-        """Performs augmentations on provided data
+        """Performs augmentations on provided data.
 
         Args:
             data (List[Tuple[np.ndarray, Dict[LabelType, np.ndarray]]]): Data with list of input images and their annotations
@@ -203,7 +211,7 @@ def __call__(
     def prepare_img_annotations(
         self, annotations: Dict[LabelType, np.ndarray], ih: int, iw: int
     ) -> Tuple[np.ndarray]:
-        """Prepare annotations to be compatible with albumentations
+        """Prepare annotations to be compatible with albumentations.
 
         Args:
             annotations (Dict[LabelType, np.ndarray]): Dict with annotations
@@ -257,7 +265,7 @@ def post_transform_process(
         nk: int,
         filter_kpts_by_bbox: bool,
     ) -> Tuple[np.ndarray]:
-        """Postprocessing of albumentations output to LuxonisLoader format
+        """Postprocessing of albumentations output to LuxonisLoader format.
 
         Args:
             transformed_data (Dict[str, np.ndarray]): Output data from albumentations
@@ -318,7 +326,7 @@ def post_transform_process(
         return out_image, out_mask, out_bboxes, out_keypoints
 
     def check_bboxes(self, bboxes: np.ndarray) -> np.ndarray:
-        """Check bbox annotations and correct those with width or height 0"""
+        """Check bbox annotations and correct those with width or height 0."""
         for i in range(bboxes.shape[0]):
             if bboxes[i, 2] == 0:
                 bboxes[i, 2] = 1
@@ -329,7 +337,7 @@ def check_bboxes(self, bboxes: np.ndarray) -> np.ndarray:
     def mark_invisible_keypoints(
         self, keypoints: np.ndarray, ih: int, iw: int
     ) -> np.ndarray:
-        """Mark invisible keypoints with label == 0"""
+        """Mark invisible keypoints with label == 0."""
         for kp in keypoints:
             if not (0 <= kp[0] < iw and 0 <= kp[1] < ih):
                 kp[2] = 0
@@ -346,7 +354,7 @@ def __init__(
         train_rgb: bool = True,
         keep_aspect_ratio: bool = True,
     ):
-        """Class for train augmentations
+        """Class for train augmentations.
 
         Args:
             image_size (List[int]): Desired image size
@@ -371,7 +379,8 @@ def __init__(
         train_rgb: bool = True,
         keep_aspect_ratio: bool = True,
     ):
-        """Class for validation augmentations which performs only normalization (if present) and resize
+        """Class for validation augmentations which performs only normalization
+        (if present) and resize.
 
         Args:
             image_size (List[int]): Desired image size
@@ -479,13 +488,6 @@ def __init__(
 AUGMENTATIONS.register_module(module=A.Transpose)
 AUGMENTATIONS.register_module(module=A.VerticalFlip)
 
-from albumentations.core.transforms_interface import (
-    BoxInternalType,
-    DualTransform,
-    KeypointInternalType,
-)
-from albumentations.core.bbox_utils import denormalize_bbox, normalize_bbox
-
 
 @AUGMENTATIONS.register_module()
 class LetterboxResize(DualTransform):
@@ -560,7 +562,7 @@ def apply(
         pad_bottom: int,
         pad_left: int,
         pad_right: int,
-        **params
+        **params,
     ) -> np.ndarray:
         resized_img = cv2.resize(
             img,
@@ -586,7 +588,7 @@ def apply_to_mask(
         pad_bottom: int,
         pad_left: int,
         pad_right: int,
-        **params
+        **params,
     ) -> np.ndarray:
         resized_img = cv2.resize(
             img,
@@ -612,7 +614,7 @@ def apply_to_bbox(
         pad_bottom: int,
         pad_left: int,
         pad_right: int,
-        **params
+        **params,
     ) -> BoxInternalType:
         x_min, y_min, x_max, y_max = denormalize_bbox(
             bbox, self.height - pad_top - pad_bottom, self.width - pad_left - pad_right
@@ -634,7 +636,7 @@ def apply_to_keypoint(
         pad_bottom: int,
         pad_left: int,
         pad_right: int,
-        **params
+        **params,
     ) -> KeypointInternalType:
         x, y, angle, scale = keypoint[:4]
         scale_x = (self.width - pad_left - pad_right) / params["cols"]
@@ -658,7 +660,7 @@ def get_transform_init_args_names(self) -> Tuple[str, ...]:
         return ("height", "width", "interpolation", "border_value", "mask_value")
 
     def _out_of_bounds(self, value: float, min_limit: float, max_limit: float) -> bool:
-        """Check if value is out of set range"""
+        """Check if value is out of set range."""
         return value < min_limit or value > max_limit
 
 
diff --git a/src/luxonis_ml/data/dataset.py b/src/luxonis_ml/data/dataset.py
index a15cfdf2..11eca8a0 100644
--- a/src/luxonis_ml/data/dataset.py
+++ b/src/luxonis_ml/data/dataset.py
@@ -1,7 +1,7 @@
 import os
+import os.path as osp
 import shutil
 import time
-from pathlib import Path
 import json
 import logging
 from tqdm import tqdm
@@ -16,12 +16,14 @@
 from luxonis_ml.utils import LuxonisFileSystem, environ
 from luxonis_ml.data.utils.parquet import ParquetFileManager
 from .utils.constants import LDF_VERSION, LABEL_TYPES
-from .utils.enums import BucketType, BucketStorage, MediaType, ImageType, DataLabelType
+from .utils.enums import BucketType, BucketStorage, MediaType, ImageType
 
 
 class LuxonisComponent:
     """Abstraction for a piece of media within a source.
-    Most commonly, this abstracts an image sensor."""
+
+    Most commonly, this abstracts an image sensor.
+    """
 
     def __init__(
         self,
@@ -45,7 +47,8 @@ def __init__(
 
 
 class LuxonisSource:
-    """Abstracts the structure of a dataset and which components/media are included"""
+    """Abstracts the structure of a dataset and which components/media are
+    included."""
 
     def __init__(
         self,
@@ -70,7 +73,10 @@ def __init__(
 
 
 class LuxonisDataset:
-    """Luxonis Dataset Format (LDF). Used to define datasets in the Luxonis MLOps ecosystem"""
+    """Luxonis Dataset Format (LDF).
+
+    Used to define datasets in the Luxonis MLOps ecosystem
+    """
 
     def __init__(
         self,
@@ -81,8 +87,7 @@ def __init__(
         bucket_type: BucketType = BucketType.INTERNAL,
         bucket_storage: BucketStorage = BucketStorage.LOCAL,
     ) -> None:
-        """
-        Initializes LDF
+        """Initializes LDF.
 
         dataset_name:
             Name of the dataset
@@ -107,8 +112,8 @@ def __init__(
             )
 
         self.base_path = environ.LUXONISML_BASE_PATH
-        credentials_cache_file = str(Path(self.base_path) / "credentials.json")
-        if os.path.exists(credentials_cache_file):
+        credentials_cache_file = osp.join(self.base_path, "credentials.json")
+        if osp.exists(credentials_cache_file):
             with open(credentials_cache_file) as file:
                 self.config = json.load(file)
         else:
@@ -137,8 +142,8 @@ def __init__(
 
         self.online = self.team_id != "offline"
 
-        self.datasets_cache_file = str(Path(self.base_path) / "datasets.json")
-        if os.path.exists(self.datasets_cache_file):
+        self.datasets_cache_file = osp.join(self.base_path, "datasets.json")
+        if osp.exists(self.datasets_cache_file):
             with open(self.datasets_cache_file) as file:
                 self.datasets = json.load(file)
         else:
@@ -175,7 +180,7 @@ def __init__(
         self.logger = logging.getLogger(__name__)
 
     def __len__(self) -> int:
-        """Returns the number of instances in the dataset"""
+        """Returns the number of instances in the dataset."""
 
         if self.online:
             raise NotImplementedError
@@ -230,7 +235,7 @@ def _source_from_document(self, document: Dict) -> LuxonisSource:
         )
 
     def _get_config(self, key: str) -> str:
-        """Gets secret credentials from credentials file or ENV variables"""
+        """Gets secret credentials from credentials file or ENV variables."""
 
         if key in self.config.keys():
             return self.config[key]
@@ -240,19 +245,19 @@ def _get_config(self, key: str) -> str:
             return getattr(environ, key)
 
     def _init_path(self) -> None:
-        """Configures local path or bucket directory"""
-
-        self.local_path = str(
-            Path(self.base_path)
-            / "data"
-            / self.team_id
-            / "datasets"
-            / self.dataset_name
+        """Configures local path or bucket directory."""
+
+        self.local_path = osp.join(
+            self.base_path,
+            "data",
+            self.team_id,
+            "datasets",
+            self.dataset_name,
         )
-        self.media_path = os.path.join(self.local_path, "media")
-        self.annotations_path = os.path.join(self.local_path, "annotations")
-        self.metadata_path = os.path.join(self.local_path, "metadata")
-        self.masks_path = os.path.join(self.local_path, "masks")
+        self.media_path = osp.join(self.local_path, "media")
+        self.annotations_path = osp.join(self.local_path, "annotations")
+        self.metadata_path = osp.join(self.local_path, "metadata")
+        self.masks_path = osp.join(self.local_path, "masks")
 
         if self.bucket_storage == BucketStorage.LOCAL:
             self.path = self.local_path
@@ -268,10 +273,10 @@ def _load_df_offline(self, sync_mode: bool = False) -> Optional[pd.DataFrame]:
         if self.bucket_storage == BucketStorage.LOCAL or sync_mode:
             annotations_path = self.annotations_path
         else:
-            annotations_path = os.path.join(self.tmp_dir, "annotations")
+            annotations_path = osp.join(self.tmp_dir, "annotations")
         for file in os.listdir(annotations_path):
-            if os.path.splitext(file)[1] == ".parquet":
-                dfs.append(pd.read_parquet(os.path.join(annotations_path, file)))
+            if osp.splitext(file)[1] == ".parquet":
+                dfs.append(pd.read_parquet(osp.join(annotations_path, file)))
         if len(dfs):
             return pd.concat(dfs)
         else:
@@ -293,14 +298,14 @@ def _try_instance_id(
     def _get_file_index(self) -> Optional[pd.DataFrame]:
         index = None
         if self.bucket_storage == BucketStorage.LOCAL:
-            file_index_path = os.path.join(self.metadata_path, "file_index.parquet")
+            file_index_path = osp.join(self.metadata_path, "file_index.parquet")
         else:
-            file_index_path = os.path.join(self.tmp_dir, "file_index.parquet")
+            file_index_path = osp.join(self.tmp_dir, "file_index.parquet")
             try:
                 self.fs.get_file("metadata/file_index.parquet", file_index_path)
             except Exception:
                 pass
-        if os.path.exists(file_index_path):
+        if osp.exists(file_index_path):
             index = pd.read_parquet(file_index_path)
         return index
 
@@ -313,7 +318,7 @@ def _write_index(
         if override_path:
             file_index_path = override_path
         else:
-            file_index_path = os.path.join(self.metadata_path, "file_index.parquet")
+            file_index_path = osp.join(self.metadata_path, "file_index.parquet")
         df = pd.DataFrame(new_index)
         if index is not None:
             df = pd.concat([index, df])
@@ -328,7 +333,7 @@ def _end_time(self) -> None:
         self.logger.info(f"Took {self.t1 - self.t0} seconds")
 
     def _make_temp_dir(self) -> None:
-        if os.path.exists(self.tmp_dir):
+        if osp.exists(self.tmp_dir):
             shutil.rmtree(self.tmp_dir)
         os.makedirs(self.tmp_dir, exist_ok=False)
 
@@ -336,9 +341,8 @@ def _remove_temp_dir(self) -> None:
         shutil.rmtree(self.tmp_dir)
 
     def update_source(self, source: LuxonisSource) -> None:
-        """
-        Updates underlying source of the dataset with a new LuxonisSource
-        """
+        """Updates underlying source of the dataset with a new
+        LuxonisSource."""
 
         if self.online:
             raise NotImplementedError()
@@ -350,8 +354,8 @@ def update_source(self, source: LuxonisSource) -> None:
             self.source = source
 
     def set_classes(self, classes: List[str], task: Optional[str] = None) -> None:
-        """
-        Sets the names of classes for the dataset. This can be across all CV tasks or certain tasks
+        """Sets the names of classes for the dataset. This can be across all CV
+        tasks or certain tasks.
 
         classes:
             List of class names to set
@@ -374,7 +378,7 @@ def set_classes(self, classes: List[str], task: Optional[str] = None) -> None:
             if self.bucket_storage != BucketStorage.LOCAL:
                 classes_json = self.datasets[self.dataset_name]["classes"]
                 self._make_temp_dir()
-                local_file = os.path.join(self.tmp_dir, "classes.json")
+                local_file = osp.join(self.tmp_dir, "classes.json")
                 with open(local_file, "w") as file:
                     json.dump(classes_json, file, indent=4)
                 self.fs.put_file(local_file, "metadata/classes.json")
@@ -383,8 +387,8 @@ def set_classes(self, classes: List[str], task: Optional[str] = None) -> None:
     # TODO: method to auto-set classes per-task using pandas
 
     def set_skeletons(self, skeletons: Dict[str, Dict]) -> None:
-        """
-        Sets the semantic structure of keypoint skeletons for the classes that use keypoints
+        """Sets the semantic structure of keypoint skeletons for the classes
+        that use keypoints.
 
         skeletons: A dict mapping class name to keypoint "labels" and "edges" between keypoints.
             The length of the "labels" determines the official number of keypoints.
@@ -404,16 +408,16 @@ def set_skeletons(self, skeletons: Dict[str, Dict]) -> None:
             self._write_datasets()
 
     def sync_from_cloud(self) -> None:
-        """Downloads media from cloud bucket"""
+        """Downloads media from cloud bucket."""
 
         if self.bucket_storage == BucketStorage.LOCAL:
             self.logger.warning("This is a local dataset! Cannot sync")
         else:
             if not hasattr(self, "is_synced") or not self.is_synced:
-                local_dir = os.path.join(
+                local_dir = osp.join(
                     self.base_path, "data", self.team_id, "datasets", self.dataset_name
                 )
-                if not os.path.exists(local_dir):
+                if not osp.exists(local_dir):
                     os.makedirs(local_dir, exist_ok=True)
 
                 protocol = self.bucket_storage.value
@@ -425,7 +429,8 @@ def sync_from_cloud(self) -> None:
                 self.is_synced = True
 
     def get_classes(self, sync_mode: bool = False) -> Tuple[List[str], Dict]:
-        """Gets overall classes in the dataset and classes according to CV task"""
+        """Gets overall classes in the dataset and classes according to CV
+        task."""
 
         if self.online:
             raise NotImplementedError()
@@ -433,7 +438,7 @@ def get_classes(self, sync_mode: bool = False) -> Tuple[List[str], Dict]:
             classes = set()
             classes_by_task = {}
             if sync_mode:
-                local_file = os.path.join(self.metadata_path, "classes.json")
+                local_file = osp.join(self.metadata_path, "classes.json")
                 self.fs.get_file("metadata/classes.json", local_file)
                 with open(local_file) as file:
                     classes_json = json.load(file)
@@ -451,7 +456,8 @@ def get_classes(self, sync_mode: bool = False) -> Tuple[List[str], Dict]:
             return classes, classes_by_task
 
     def get_skeletons(self) -> Dict[str, Dict]:
-        """Returns the dictionary defining the semantic skeleton for each class using keypoints"""
+        """Returns the dictionary defining the semantic skeleton for each class
+        using keypoints."""
 
         if self.online:
             raise NotImplementedError()
@@ -459,7 +465,7 @@ def get_skeletons(self) -> Dict[str, Dict]:
             return self.datasets[self.dataset_name]["skeletons"]
 
     def delete_dataset(self) -> None:
-        """Deletes all local files belonging to the dataset"""
+        """Deletes all local files belonging to the dataset."""
 
         if self.online:
             raise NotImplementedError()
@@ -470,8 +476,7 @@ def delete_dataset(self) -> None:
                 shutil.rmtree(self.path)
 
     def add(self, generator: Generator, batch_size: int = 1000000) -> None:
-        """
-        Write annotations to parquet files.
+        """Write annotations to parquet files.
 
         generator: A python generator that yields dictionaries of data
             with the key described by the ANNOTATIONS_SCHEMA but also listed below
@@ -514,13 +519,7 @@ def _add_process_batch(batch_data: List[Dict]) -> None:
                 self._end_time()
 
             array_paths = list(
-                set(
-                    [
-                        data["value"]
-                        for data in batch_data
-                        if data["type"] == "array"
-                    ]
-                )
+                set([data["value"] for data in batch_data if data["type"] == "array"])
             )
             if len(array_paths):
                 self.logger.info("Checking arrays...")
@@ -548,16 +547,16 @@ def _add_process_batch(batch_data: List[Dict]) -> None:
                     if data["type"] == "array":
                         if self.bucket_storage != BucketStorage.LOCAL:
                             remote_path = mask_upload_dict[data["value"]]
-                            remote_path = f"{self.fs.protocol}://{os.path.join(self.fs.path, remote_path)}"
+                            remote_path = f"{self.fs.protocol}://{osp.join(self.fs.path, remote_path)}"
                             data["value"] = remote_path
                         else:
-                            data["value"] = os.path.abspath(data["value"])
+                            data["value"] = osp.abspath(data["value"])
 
             self.logger.info("Saving annotations...")
             self._start_time()
             for data in tqdm(batch_data):
                 filepath = data["file"]
-                file = os.path.basename(filepath)
+                file = osp.basename(filepath)
                 instance_id = uuid_dict[filepath]
                 matched_id = self._try_instance_id(file, index)
                 if matched_id is not None:
@@ -570,7 +569,7 @@ def _add_process_batch(batch_data: List[Dict]) -> None:
                 elif instance_id not in new_index["instance_id"]:
                     new_index["instance_id"].append(instance_id)
                     new_index["file"].append(file)
-                    new_index["original_filepath"].append(os.path.abspath(filepath))
+                    new_index["original_filepath"].append(osp.abspath(filepath))
 
                 data_utils.check_annotation(data)
                 data["instance_id"] = instance_id
@@ -596,7 +595,7 @@ def _add_process_batch(batch_data: List[Dict]) -> None:
                 self.pfm = ParquetFileManager(self.annotations_path)
             else:
                 self._make_temp_dir()
-                annotations_dir = os.path.join(self.tmp_dir, "annotations")
+                annotations_dir = osp.join(self.tmp_dir, "annotations")
                 os.makedirs(annotations_dir, exist_ok=True)
                 self.pfm = ParquetFileManager(annotations_dir)
 
@@ -618,7 +617,7 @@ def _add_process_batch(batch_data: List[Dict]) -> None:
             if self.bucket_storage == BucketStorage.LOCAL:
                 self._write_index(index, new_index)
             else:
-                file_index_path = os.path.join(".luxonis_tmp", "file_index.parquet")
+                file_index_path = osp.join(".luxonis_tmp", "file_index.parquet")
                 self._write_index(index, new_index, override_path=file_index_path)
                 self.fs.put_dir(annotations_dir, "annotations")
                 self.fs.put_file(file_index_path, "metadata/file_index.parquet")
@@ -627,8 +626,7 @@ def _add_process_batch(batch_data: List[Dict]) -> None:
     def make_splits(
         self, ratios: List[float] = [0.8, 0.1, 0.1], definitions: Optional[Dict] = None
     ) -> None:
-        """
-        Saves a splits.json file that specified the train/val/test split.
+        """Saves a splits.json file that specified the train/val/test split.
         For use in OFFLINE mode only.
 
         ratios [List[float]] : length 3 list of train/val/test ratios in that order used for a random split.
@@ -649,7 +647,7 @@ def make_splits(
                 if self.bucket_storage != BucketStorage.LOCAL:
                     self._make_temp_dir()
                     self.fs.get_dir(
-                        "annotations", os.path.join(self.tmp_dir, "annotations")
+                        "annotations", osp.join(self.tmp_dir, "annotations")
                     )
 
                 df = self._load_df_offline()
@@ -673,15 +671,15 @@ def make_splits(
                     files = definitions[split]
                     if not isinstance(files, list):
                         raise Exception("Must provide splits as a list of str")
-                    files = [os.path.basename(file) for file in files]
+                    files = [osp.basename(file) for file in files]
                     ids = [self._try_instance_id(file, index) for file in files]
                     splits[split] = ids
 
             if self.bucket_storage == BucketStorage.LOCAL:
-                with open(os.path.join(self.metadata_path, "splits.json"), "w") as file:
+                with open(osp.join(self.metadata_path, "splits.json"), "w") as file:
                     json.dump(splits, file, indent=4)
             else:
-                local_file = os.path.join(self.tmp_dir, "splits.json")
+                local_file = osp.join(self.tmp_dir, "splits.json")
                 with open(local_file, "w") as file:
                     json.dump(splits, file, indent=4)
                 self.fs.put_file(local_file, "metadata/splits.json")
@@ -689,11 +687,14 @@ def make_splits(
 
     @staticmethod
     def exists(dataset_name: str) -> bool:
-        """Returns whether the dataset under a given name exists. For offline mode only"""
+        """Returns whether the dataset under a given name exists.
+
+        For offline mode only
+        """
 
         base_path = environ.LUXONISML_BASE_PATH
-        datasets_cache_file = str(Path(base_path) / "datasets.json")
-        if os.path.exists(datasets_cache_file):
+        datasets_cache_file = osp.join(base_path, "datasets.json")
+        if osp.exists(datasets_cache_file):
             with open(datasets_cache_file) as file:
                 datasets = json.load(file)
         else:
diff --git a/src/luxonis_ml/data/dataset_recognition.py b/src/luxonis_ml/data/dataset_recognition.py
index 26bbbe4d..e71926aa 100644
--- a/src/luxonis_ml/data/dataset_recognition.py
+++ b/src/luxonis_ml/data/dataset_recognition.py
@@ -7,8 +7,7 @@
 
 # TODO: place for common parser args
 def recognize(dataset_path: str) -> str:
-    """
-    dataset_path (str): Path to the root folder of the dataset.
+    """dataset_path (str): Path to the root folder of the dataset.
 
     NOTE: Dataset type checking is done by some significant property of the dataset (has to contain json file, yaml file,..).
     """
diff --git a/src/luxonis_ml/data/fiftyone_plugins/__init__.py b/src/luxonis_ml/data/fiftyone_plugins/__init__.py
index 89578eea..967290a0 100644
--- a/src/luxonis_ml/data/fiftyone_plugins/__init__.py
+++ b/src/luxonis_ml/data/fiftyone_plugins/__init__.py
@@ -1 +1,14 @@
-from .database import *
+from .database import (
+    LuxonisDatasetDocument,
+    LuxonisSourceDocument,
+    VersionDocument,
+    TransactionDocument,
+)
+
+
+__all__ = [
+    "LuxonisDatasetDocument",
+    "LuxonisSourceDocument",
+    "VersionDocument",
+    "TransactionDocument",
+]
diff --git a/src/luxonis_ml/data/fiftyone_plugins/database.py b/src/luxonis_ml/data/fiftyone_plugins/database.py
index 1300f7f8..c9ecc930 100644
--- a/src/luxonis_ml/data/fiftyone_plugins/database.py
+++ b/src/luxonis_ml/data/fiftyone_plugins/database.py
@@ -11,7 +11,6 @@
 )
 
 from fiftyone.core.odm.document import Document
-from fiftyone.core.odm.dataset import DatasetDocument
 
 
 class LuxonisDatasetDocument(Document):
diff --git a/src/luxonis_ml/data/loader.py b/src/luxonis_ml/data/loader.py
index dcb1c55a..bf8b7240 100644
--- a/src/luxonis_ml/data/loader.py
+++ b/src/luxonis_ml/data/loader.py
@@ -10,11 +10,11 @@
 import pandas as pd
 from abc import ABC, abstractmethod
 from typing import Optional, Tuple, Dict
-from pathlib import Path
 import pycocotools.mask as mask_util
 from luxonis_ml.enums import LabelType
-from luxonis_ml.utils import LuxonisFileSystem
 from .utils.enums import BucketStorage
+from .dataset import LuxonisDataset
+from .augmentations import Augmentations
 
 
 Labels = Dict[LabelType, np.ndarray]
@@ -22,16 +22,17 @@
 
 
 class BaseLoader(ABC):
-    """Base abstract loader class that enforces LuxonisLoaderOutput output label structure."""
+    """Base abstract loader class that enforces LuxonisLoaderOutput output
+    label structure."""
 
     @abstractmethod
     def __len__(self) -> int:
-        """Returns length of the dataset"""
+        """Returns length of the dataset."""
         pass
 
     @abstractmethod
     def __getitem__(self, idx: int) -> LuxonisLoaderOutput:
-        """Loads sample from dataset
+        """Loads sample from dataset.
 
         Args:
             idx (int): Sample index
@@ -45,12 +46,12 @@ def __getitem__(self, idx: int) -> LuxonisLoaderOutput:
 class LuxonisLoader(BaseLoader):
     def __init__(
         self,
-        dataset: "luxonis_ml.data.LuxonisDataset",
+        dataset: LuxonisDataset,
         view: str = "train",
         stream: bool = False,
-        augmentations: Optional["luxonis_ml.loader.Augmentations"] = None,
+        augmentations: Optional[Augmentations] = None,
     ) -> None:
-        """LuxonisLoader used for loading LuxonisDataset
+        """LuxonisLoader used for loading LuxonisDataset.
 
         Args:
             dataset (luxonis_ml.data.LuxonisDataset): LuxonisDataset to use
@@ -116,11 +117,11 @@ def __init__(
         self.df.set_index(["instance_id"], inplace=True)
 
     def __len__(self) -> int:
-        """Returns length of the pytorch dataset"""
+        """Returns length of the pytorch dataset."""
         return len(self.instances)
 
     def __getitem__(self, idx: int) -> LuxonisLoaderOutput:
-        """Function to load a sample"""
+        """Function to load a sample."""
 
         img, annotations = self._load_image_with_annotations(idx)
 
diff --git a/src/luxonis_ml/data/utils/data_utils.py b/src/luxonis_ml/data/utils/data_utils.py
index 82984e8c..fe48f838 100644
--- a/src/luxonis_ml/data/utils/data_utils.py
+++ b/src/luxonis_ml/data/utils/data_utils.py
@@ -10,11 +10,10 @@
 import typing
 from typing import Dict, List, Union, Any, Tuple
 from .constants import ANNOTATIONS_SCHEMA as schema
-from .enums import DataLabelType
 
 
 def generate_hashname(filepath: str) -> Tuple[str, str]:
-    """Finds the UUID generated ID for a local file"""
+    """Finds the UUID generated ID for a local file."""
 
     # Read the contents of the file
     with open(filepath, "rb") as file:
@@ -29,7 +28,8 @@ def generate_hashname(filepath: str) -> Tuple[str, str]:
 
 
 def check_annotation(data: Dict) -> None:
-    """Throws an exception if the input data does not match the expected annotations schema"""
+    """Throws an exception if the input data does not match the expected
+    annotations schema."""
 
     if len(schema.keys()) != len(data.keys()) or set(schema.keys()) != set(data.keys()):
         raise Exception(
@@ -94,7 +94,7 @@ def check_annotation(data: Dict) -> None:
 
 
 def check_arrays(values: List[Any]) -> None:
-    """Throws an exception if a given path to an array is invalid"""
+    """Throws an exception if a given path to an array is invalid."""
 
     for value in values:
         _check_array(value)
diff --git a/src/luxonis_ml/data/utils/enums.py b/src/luxonis_ml/data/utils/enums.py
index 062215d9..8b5b07d8 100644
--- a/src/luxonis_ml/data/utils/enums.py
+++ b/src/luxonis_ml/data/utils/enums.py
@@ -3,10 +3,10 @@
 
 class DataLabelType(Enum):
     """Supported computer vision label types.
-    Annotation types can be nested
-    (e.g. a BOX has 2 LABELS,
-        a BOX has a POLYLINE instance segmentation,
-        etc.)"""
+
+    Annotation types can be nested (e.g. a BOX has 2 LABELS,     a BOX
+    has a POLYLINE instance segmentation,     etc.)
+    """
 
     CLASSIFICATION = (
         "classification"  # used for single, multi-class, or multi-label classification
@@ -20,7 +20,7 @@ class DataLabelType(Enum):
 
 
 class MediaType(Enum):
-    """Individual file type"""
+    """Individual file type."""
 
     IMAGE = "image"
     VIDEO = "video"
@@ -28,7 +28,7 @@ class MediaType(Enum):
 
 
 class ImageType(Enum):
-    """Image type for IMAGE HType"""
+    """Image type for IMAGE HType."""
 
     COLOR = "color"
     MONO = "mono"
@@ -36,7 +36,7 @@ class ImageType(Enum):
 
 
 class LDFTransactionType(Enum):
-    """The type of transaction"""
+    """The type of transaction."""
 
     END = "END"
     ADD = "ADD"
@@ -45,14 +45,14 @@ class LDFTransactionType(Enum):
 
 
 class BucketType(Enum):
-    """Whether storage is internal or external"""
+    """Whether storage is internal or external."""
 
     INTERNAL = "internal"
     EXTERNAL = "external"
 
 
 class BucketStorage(Enum):
-    """Underlying object storage for a bucket"""
+    """Underlying object storage for a bucket."""
 
     LOCAL = "local"
     S3 = "s3"
diff --git a/src/luxonis_ml/data/utils/labelstudio.py b/src/luxonis_ml/data/utils/labelstudio.py
index 05ad91d8..6b15e856 100644
--- a/src/luxonis_ml/data/utils/labelstudio.py
+++ b/src/luxonis_ml/data/utils/labelstudio.py
@@ -1,17 +1,16 @@
 import numpy as np
 import os
 import xml.etree.ElementTree as ET
-from typing import List
 
 
 def generate_random_color():
-    """Generates random RGB color"""
+    """Generates random RGB color."""
 
     return [np.random.randint(0, 255) for _ in range(3)]
 
 
 def get_xml_config(dataset) -> str:
-    """Returns the labelstudio XML for a LuxonisDataset"""
+    """Returns the labelstudio XML for a LuxonisDataset."""
 
     root = ET.Element("View")
 
@@ -21,7 +20,6 @@ def get_xml_config(dataset) -> str:
     image.set("zoom", "true")
 
     classes = dataset.fo_dataset.classes
-
     if "class" in classes and len(classes["class"]):
         choices = ET.SubElement(root, "Choices")
         choices.set("name", "choice")
diff --git a/src/luxonis_ml/data/utils/parquet.py b/src/luxonis_ml/data/utils/parquet.py
index 50df6a0d..87d6e616 100644
--- a/src/luxonis_ml/data/utils/parquet.py
+++ b/src/luxonis_ml/data/utils/parquet.py
@@ -1,6 +1,6 @@
-import os, io
-import numpy as np
-from typing import Tuple, Optional, Dict
+import os
+import io
+from typing import Tuple, Dict
 import pandas as pd
 import pyarrow as pa
 import pyarrow.parquet as pq
@@ -13,9 +13,7 @@ def __init__(
         file_size_mb: int = 20,
         row_check: int = 100000,
     ) -> None:
-        """
-        Class to manage the insert of data into parquet files.
-        """
+        """Class to manage the insert of data into parquet files."""
 
         self.dir = directory
         self.files = os.listdir(self.dir)
@@ -33,7 +31,8 @@ def __init__(
         self._read()
 
     def _get_current_parquet_file(self) -> str:
-        """Finds the best parquet file to edit based on the file size and most last write time"""
+        """Finds the best parquet file to edit based on the file size and most
+        last write time."""
 
         path = self._generate_filename(self.num)[1]
         current_size = os.path.getsize(path) / (1024 * 1024)
@@ -76,7 +75,7 @@ def _estimate_file_size(self, df: pd.DataFrame) -> float:
             return buffer.tell() / (1024 * 1024)
 
     def write(self, add_data: Dict) -> None:
-        """Writes a row to the current working parquet file"""
+        """Writes a row to the current working parquet file."""
         if len(self.data) == 0:
             self._initialize_data(add_data)
         for key in add_data:
@@ -95,7 +94,7 @@ def write(self, add_data: Dict) -> None:
                 self._read()
 
     def close(self) -> None:
-        """Ensure all data is written to parquet"""
+        """Ensure all data is written to parquet."""
 
         df = pd.DataFrame(self.data)
         table = pa.Table.from_pandas(df)
diff --git a/src/luxonis_ml/embeddings/__init__.py b/src/luxonis_ml/embeddings/__init__.py
index f3ebf8a2..2ede97da 100644
--- a/src/luxonis_ml/embeddings/__init__.py
+++ b/src/luxonis_ml/embeddings/__init__.py
@@ -1,5 +1,52 @@
 from ..guard_extras import guard_missing_extra
 
 with guard_missing_extra("embedd"):
-    from .methods import *
-    from .utils import *
+    from .methods import (
+        find_similar_qdrant,
+        find_mismatches_centroids,
+        find_mismatches_knn,
+        isolation_forest_OOD,
+        leverage_OOD,
+        calculate_similarity_matrix,
+        find_representative_greedy,
+        find_representative_kmedoids,
+    )
+    from .utils import (
+        load_model_resnet50_minuslastlayer,
+        load_model,
+        export_model_onnx,
+        load_model_onnx,
+        extend_output_onnx,
+        extend_output_onnx_overwrite,
+        QdrantManager,
+        QdrantAPI,
+        extract_embeddings,
+        extract_embeddings_onnx,
+        save_embeddings,
+        load_embeddings,
+        generate_embeddings,
+    )
+
+__all__ = [
+    "find_similar_qdrant",
+    "find_mismatches_centroids",
+    "find_mismatches_knn",
+    "isolation_forest_OOD",
+    "leverage_OOD",
+    "calculate_similarity_matrix",
+    "find_representative_greedy",
+    "find_representative_kmedoids",
+    "load_model_resnet50_minuslastlayer",
+    "load_model",
+    "export_model_onnx",
+    "load_model_onnx",
+    "extend_output_onnx",
+    "extend_output_onnx_overwrite",
+    "QdrantManager",
+    "QdrantAPI",
+    "extract_embeddings",
+    "extract_embeddings_onnx",
+    "save_embeddings",
+    "load_embeddings",
+    "generate_embeddings",
+]
diff --git a/src/luxonis_ml/embeddings/methods/OOD.py b/src/luxonis_ml/embeddings/methods/OOD.py
index 94e4fda3..20070319 100644
--- a/src/luxonis_ml/embeddings/methods/OOD.py
+++ b/src/luxonis_ml/embeddings/methods/OOD.py
@@ -1,41 +1,37 @@
-"""
-Out-of-Distribution Detection for Embeddings
+"""Out-of-Distribution Detection for Embeddings.
 
-This module provides two primary methods for detecting out-of-distribution (OOD) samples 
-in embeddings. OOD samples can be crucial to identify as they represent anomalies or novel 
+This module provides two primary methods for detecting out-of-distribution (OOD) samples
+in embeddings. OOD samples can be crucial to identify as they represent anomalies or novel
 patterns that don't conform to the expected distribution of the dataset.
 
 Methods available:
-- Isolation Forests: A tree-based model that partitions the space in such a manner that 
+- Isolation Forests: A tree-based model that partitions the space in such a manner that
   anomalies are isolated from the rest.
-  
-- Leverage with Linear Regression: Leverages (or hat values) represent the distance between 
+
+- Leverage with Linear Regression: Leverages (or hat values) represent the distance between
   the predicted values and the true values. Higher leverages indicate potential OOD points.
 
 Typical use cases include:
 - Anomaly Detection: Identifying rare patterns or outliers.
-  
+
 - Dataset Reduction: By removing or studying OOD samples, we can have a more homogeneous dataset.
-  
-- Expanding Datasets: Recognizing valuable data points that are distinct from the current distribution can be helpful 
+
+- Expanding Datasets: Recognizing valuable data points that are distinct from the current distribution can be helpful
   when we're looking to diversify the dataset, especially in iterative learning scenarios.
 
 Dependencies:
 - numpy
 - scikit-learn
-
 """
 
 import numpy as np
 from sklearn.ensemble import IsolationForest
-from sklearn.linear_model import LinearRegression
 
 
 def isolation_forest_OOD(
     X, contamination="auto", n_jobs=-1, verbose=1, random_state=None
 ):
-    """
-    Out-of-distribution detection using Isolation Forests.
+    """Out-of-distribution detection using Isolation Forests.
 
     Parameters
     ----------
@@ -54,7 +50,6 @@ def isolation_forest_OOD(
     -------
     np.array
         The indices of the embeddings that are in-distribution.
-
     """
     # Initialize the Isolation Forest model
     isolation_forest = IsolationForest(
@@ -77,8 +72,7 @@ def isolation_forest_OOD(
 
 
 def leverage_OOD(X, std_threshold=3):
-    """
-    Out-of-distribution detection using leverage and linear regression.
+    """Out-of-distribution detection using leverage and linear regression.
 
     Parameters
     ----------
@@ -91,7 +85,6 @@ def leverage_OOD(X, std_threshold=3):
     -------
     np.array
         The indices of the embeddings that are out-of-distribution.
-
     """
     # Calculate the hat matrix (projection matrix) to get the leverage for each point
     hat_matrix = np.matmul(np.matmul(X, np.linalg.inv(np.matmul(X.T, X))), X.T)
diff --git a/src/luxonis_ml/embeddings/methods/duplicate.py b/src/luxonis_ml/embeddings/methods/duplicate.py
index 83673902..1b21aa95 100644
--- a/src/luxonis_ml/embeddings/methods/duplicate.py
+++ b/src/luxonis_ml/embeddings/methods/duplicate.py
@@ -1,9 +1,8 @@
-"""
-Near-duplicate Search with Qdrant
+"""Near-duplicate Search with Qdrant.
 
 This module provides utilities to detect and remove near-duplicate data points
-within a given set of embeddings. The removal process uses Kernel Density 
-Estimation (KDE) on embeddings cosine similarity for optimal split, making 
+within a given set of embeddings. The removal process uses Kernel Density
+Estimation (KDE) on embeddings cosine similarity for optimal split, making
 this approach particularly suited for embeddings in high dimensional spaces.
 
 Functionality Includes:
@@ -64,12 +63,9 @@
 
 # Near-duplicate search
 from scipy.signal import argrelextrema
-from scipy.stats import gaussian_kde
-import scipy.spatial.distance as distance
 from KDEpy import FFTKDE
 
 # Qdrant
-from luxonis_ml.embeddings.utils.qdrant import QdrantAPI
 
 
 def search_qdrant(qdrant_api, query_vector, data_name, limit=5000):
@@ -84,9 +80,7 @@ def search_qdrant(qdrant_api, query_vector, data_name, limit=5000):
 
 
 def _plot_kde(xs, s, density, maxima, minima):
-    """
-    Plot a KDE distribution.
-    """
+    """Plot a KDE distribution."""
     plt.plot(xs, density, label="KDE")
     plt.plot(xs[maxima], s[maxima], "ro", label="local maxima")
     plt.plot(xs[minima], s[minima], "bo", label="local minima")
@@ -96,9 +90,8 @@ def _plot_kde(xs, s, density, maxima, minima):
 
 
 def kde_peaks(data, bandwidth="scott", plot=False):
-    """
-    Find peaks in a KDE distribution using scipy's argrelextrema function.
-    """
+    """Find peaks in a KDE distribution using scipy's argrelextrema
+    function."""
     # fit density
     kde = FFTKDE(kernel="gaussian", bw=bandwidth)
     xs = np.linspace(np.min(data) - 0.01, np.max(data) + 0.01, 1000)
@@ -133,8 +126,7 @@ def find_similar_qdrant(
     kde_bw="scott",
     plot=False,
 ):
-    """
-    Find the most similar embeddings to the reference embeddings.
+    """Find the most similar embeddings to the reference embeddings.
 
     Parameters
     ----------
@@ -175,7 +167,6 @@ def find_similar_qdrant(
         The instance_ids of the most similar embeddings.
     np.array
         The image_paths of the most similar embeddings.
-
     """
     # Get the reference embeddings
     # check if reference_embeddings is a list of instance_ids
diff --git a/src/luxonis_ml/embeddings/methods/mistakes.py b/src/luxonis_ml/embeddings/methods/mistakes.py
index 34b55f1b..00b435be 100644
--- a/src/luxonis_ml/embeddings/methods/mistakes.py
+++ b/src/luxonis_ml/embeddings/methods/mistakes.py
@@ -1,16 +1,15 @@
-"""
-Mismatch Detection in Labelled Data
+"""Mismatch Detection in Labelled Data.
 
-This module provides functionalities to detect mismatches or potential mislabelling 
-in a dataset based on various strategies. This is crucial in supervised machine 
+This module provides functionalities to detect mismatches or potential mislabelling
+in a dataset based on various strategies. This is crucial in supervised machine
 learning tasks where the quality of labels significantly affects model performance.
 
 Methods implemented:
-    - Centroids: This method identifies mismatches by comparing the distance of data points 
-                 to the centroid of their own class against the distances to centroids of 
+    - Centroids: This method identifies mismatches by comparing the distance of data points
+                 to the centroid of their own class against the distances to centroids of
                  other classes.
-    - KNN (k-Nearest Neighbors): This approach leverages the idea that if the majority of data 
-                                 is correctly labelled, then mislabelled data will be corrected 
+    - KNN (k-Nearest Neighbors): This approach leverages the idea that if the majority of data
+                                 is correctly labelled, then mislabelled data will be corrected
                                  by its nearest neighbors.
     - [Note: DBSCAN was considered but not implemented due to underperformance.]
 
@@ -21,7 +20,7 @@
 
     # Detect mismatches using centroids
     mismatches, new_labels = find_mismatches_centroids(X_train, y_train)
-    
+
     # Detect mismatches using KNN
     mismatches, new_labels = find_mismatches_knn(X_train, y_train)
     ```
@@ -34,9 +33,8 @@
 
 
 def find_mismatches_centroids(X, y):
-    """
-    Find mismatches in the dataset.
-    A mismatch is defined as a sample that is closer to another centroid than to its own centroid.
+    """Find mismatches in the dataset. A mismatch is defined as a sample that
+    is closer to another centroid than to its own centroid.
 
     Parameters
     ----------
diff --git a/src/luxonis_ml/embeddings/methods/representative.py b/src/luxonis_ml/embeddings/methods/representative.py
index 563c2d8c..9efcad9d 100644
--- a/src/luxonis_ml/embeddings/methods/representative.py
+++ b/src/luxonis_ml/embeddings/methods/representative.py
@@ -1,17 +1,16 @@
-"""
-Find Representative Images from Embeddings
+"""Find Representative Images from Embeddings.
 
 This module offers techniques to identify representative images or embeddings within a dataset.
 This aids in achieving a condensed yet expressive view of your data.
 
 Methods:
 - Greedy Search: Aims to find a diverse subset of images by maximizing the minimum similarity to any image outside the set.
-  
+
 - K-Medoids: An adaptation of the k-means clustering algorithm, it partitions data into k clusters, each associated with a medoid.
 
 Main Applications:
 - Dataset Reduction: Helps in representing large datasets with a minimal subset while retaining the essence.
-  
+
 - Validation Set Creation: Identifies diverse samples for a robust validation set.
 
 Dependencies:
@@ -38,24 +37,20 @@
     desired_size = int(len(embeddings) * 0.1)
     selected_image_indices = find_representative_kmedoids(similarity_matrix, desired_size)
     ```
-
 """
 
 import numpy as np
 from sklearn.metrics.pairwise import cosine_similarity
 from kmedoids import KMedoids
 
-from luxonis_ml.embeddings.utils.qdrant import QdrantAPI
-
 
 def calculate_similarity_matrix(embeddings):
     return cosine_similarity(embeddings)
 
 
 def find_representative_greedy(distance_matrix, desired_size=1000, seed=0):
-    """
-    Find the most representative images using a greedy algorithm.
-    Gready search of maximally unique embeddings
+    """Find the most representative images using a greedy algorithm. Gready
+    search of maximally unique embeddings.
 
     Parameters
     ----------
@@ -150,9 +145,8 @@ def find_representative_greedy_qdrant(qdrant_api, desired_size=1000, seed=None):
 def find_representative_kmedoids(
     similarity_matrix, desired_size=1000, max_iter=100, seed=None
 ):
-    """
-    Find the most representative images using k-medoids.
-    K-medoids clustering of embeddings
+    """Find the most representative images using k-medoids. K-medoids
+    clustering of embeddings.
 
     Parameters
     ----------
diff --git a/src/luxonis_ml/embeddings/requirements.txt b/src/luxonis_ml/embeddings/requirements.txt
index 687174fa..d2abf5a0 100644
--- a/src/luxonis_ml/embeddings/requirements.txt
+++ b/src/luxonis_ml/embeddings/requirements.txt
@@ -10,6 +10,6 @@ opencv-python>=4.7.0.68
 qdrant-client>=1.4.0
 scikit-learn>=1.3.0
 scipy>=1.10.1
-# torch==1.13.1+cu116
-# torchaudio==0.13.1+cu116
-# torchvision==0.14.1+cu116
+torch>=1.13.1
+torchaudio>=0.13.1
+torchvision>=0.14.1
diff --git a/src/luxonis_ml/embeddings/utils/embedding.py b/src/luxonis_ml/embeddings/utils/embedding.py
index 5d36b127..664efb1b 100644
--- a/src/luxonis_ml/embeddings/utils/embedding.py
+++ b/src/luxonis_ml/embeddings/utils/embedding.py
@@ -1,40 +1,39 @@
-"""
-Embeddings Extractor and Storage
+"""Embeddings Extractor and Storage.
 
-This module provides utility functions for extracting embeddings from both PyTorch and ONNX models, 
+This module provides utility functions for extracting embeddings from both PyTorch and ONNX models,
 and subsequently storing and retrieving these embeddings from disk.
 
 Functions:
-    - extract_embeddings(model, data_loader): 
+    - extract_embeddings(model, data_loader):
       Extracts embeddings from a given PyTorch model using data from a specified DataLoader.
-      
+
     - extract_embeddings_onnx(ort_session, data_loader, output_layer_name):
-      Extracts embeddings from a specified ONNX model (provided as an ONNX Runtime session) 
+      Extracts embeddings from a specified ONNX model (provided as an ONNX Runtime session)
       using data from a specified DataLoader. Allows targeting a specific output layer for extraction.
-      
+
     - save_embeddings(embeddings, labels, save_path):
       Saves both embeddings and their associated labels to the disk at a given path.
-      
+
     - load_embeddings(save_path):
       Loads embeddings and their associated labels from the disk at a given path.
 
 Usage Examples:
     1. Extract embeddings from a PyTorch model:
         embeddings, labels = extract_embeddings(pytorch_model, data_loader)
-    
+
     2. Extract embeddings from an ONNX model:
         ort_session = ort.InferenceSession('model.onnx')
         embeddings, labels = extract_embeddings_onnx(ort_session, data_loader, "/Flatten_output_0")
-    
+
     3. Save embeddings to disk:
         save_embeddings(embeddings, labels, "./embeddings/")
-    
+
     4. Load embeddings from disk:
         loaded_embeddings, loaded_labels = load_embeddings("./embeddings/")
 
 Note:
-    Ensure the DataLoader provided to the extraction functions outputs batches 
-    in the form (data, labels). Make sure to match the output_layer_name in the ONNX extraction 
+    Ensure the DataLoader provided to the extraction functions outputs batches
+    in the form (data, labels). Make sure to match the output_layer_name in the ONNX extraction
     with the appropriate output layer's name from the ONNX model.
 
 Dependencies:
@@ -45,17 +44,14 @@
 """
 
 import torch
-import torchvision
 import onnxruntime as ort
-from typing import Tuple, Union
+from typing import Tuple
 
 
 def extract_embeddings(
     model: torch.nn.Module, data_loader: torch.utils.data.DataLoader
 ) -> Tuple[torch.Tensor, torch.Tensor]:
-    """
-    Extract embeddings from the given PyTorch model.
-    """
+    """Extract embeddings from the given PyTorch model."""
     embeddings = []
     labels = []
 
@@ -73,9 +69,7 @@ def extract_embeddings_onnx(
     data_loader: torch.utils.data.DataLoader,
     output_layer_name: str,
 ) -> Tuple[torch.Tensor, torch.Tensor]:
-    """
-    Extract embeddings from the given ONNX model.
-    """
+    """Extract embeddings from the given ONNX model."""
     embeddings = []
     labels = []
 
@@ -92,17 +86,13 @@ def extract_embeddings_onnx(
 def save_embeddings(
     embeddings: torch.Tensor, labels: torch.Tensor, save_path: str = "./"
 ):
-    """
-    Save embeddings and labels tensors to the specified path.
-    """
+    """Save embeddings and labels tensors to the specified path."""
     torch.save(embeddings, save_path + "embeddings.pth")
     torch.save(labels, save_path + "labels.pth")
 
 
 def load_embeddings(save_path: str = "./") -> Tuple[torch.Tensor, torch.Tensor]:
-    """
-    Load embeddings and labels tensors from the specified path.
-    """
+    """Load embeddings and labels tensors from the specified path."""
     embeddings = torch.load(save_path + "embeddings.pth")
     labels = torch.load(save_path + "labels.pth")
 
diff --git a/src/luxonis_ml/embeddings/utils/ldf.py b/src/luxonis_ml/embeddings/utils/ldf.py
index f6f19df3..5daf9c81 100644
--- a/src/luxonis_ml/embeddings/utils/ldf.py
+++ b/src/luxonis_ml/embeddings/utils/ldf.py
@@ -1,5 +1,5 @@
-"""
-This script provides utilities for generating embeddings from images, filtering new samples, and inserting them into a Qdrant database.
+"""This script provides utilities for generating embeddings from images,
+filtering new samples, and inserting them into a Qdrant database.
 
 Modules Used:
 - cv2: For reading and processing images.
@@ -25,19 +25,13 @@
 """
 
 import cv2
-import numpy as np
 import torch
 import torch.onnx
-import onnx
-import onnxruntime
-import torchvision
 import torchvision.transforms as transforms
-from qdrant_client import QdrantClient
-from qdrant_client.models import Distance, VectorParams, PointStruct, SearchRequest
+from qdrant_client.models import SearchRequest
 from qdrant_client.http import models
 
-from luxonis_ml.data.dataset import LuxonisDataset
-from luxonis_ml.embeddings.utils.qdrant import QdrantAPI
+from luxonis_ml.data import LuxonisDataset
 
 
 def _get_sample_payloads_coco(luxonis_dataset: LuxonisDataset):
@@ -80,8 +74,7 @@ def _get_sample_payloads_coco(luxonis_dataset: LuxonisDataset):
 
 
 def _get_sample_payloads(luxonis_dataset: LuxonisDataset):
-    """
-    Extract payloads from the LuxonisDataset.
+    """Extract payloads from the LuxonisDataset.
 
     Args:
         luxonis_dataset: The dataset object.
@@ -117,8 +110,9 @@ def _get_sample_payloads(luxonis_dataset: LuxonisDataset):
 def _filter_new_samples(
     qdrant_client, collection_name, vector_size=2048, all_payloads=[]
 ):
-    """
-    Filter out samples that are already in the Qdrant database based on their sample ID.
+    """Filter out samples that are already in the Qdrant database based on
+    their sample ID.
+
     Args:
         qdrant_client: Qdrant client instance.
         collection_name: Name of the Qdrant collection.
@@ -154,8 +148,9 @@ def _filter_new_samples(
 
 
 def _filter_new_samples_by_id(qdrant_client, collection_name, all_payloads=[]):
-    """
-    Filter out samples that are already in the Qdrant database based on their instance ID.
+    """Filter out samples that are already in the Qdrant database based on
+    their instance ID.
+
     Args:
         qdrant_client: Qdrant client instance.
         collection_name: Name of the Qdrant collection.
@@ -191,8 +186,8 @@ def _generate_new_embeddings(
     new_payloads=[],
     transform=None,
 ):
-    """
-    Generate embeddings for new images using a given ONNX runtime session.
+    """Generate embeddings for new images using a given ONNX runtime session.
+
     Args:
         ort_session: ONNX runtime session.
         output_layer_name: Name of the output layer in the ONNX model.
@@ -243,8 +238,8 @@ def _generate_new_embeddings(
 def _batch_upsert(
     qdrant_client, collection_name, new_embeddings, new_payloads, qdrant_batch_size=64
 ):
-    """
-    Perform batch upserts of embeddings to Qdrant.
+    """Perform batch upserts of embeddings to Qdrant.
+
     Args:
         qdrant_client: Qdrant client instance.
         collection_name: Name of the Qdrant collection.
@@ -284,8 +279,8 @@ def generate_embeddings(
     emb_batch_size=64,
     qdrant_batch_size=64,
 ):
-    """
-    Generate embeddings for a given dataset and insert them into Qdrant.
+    """Generate embeddings for a given dataset and insert them into Qdrant.
+
     Args:
         luxonis_dataset: The dataset object.
         ort_session: ONNX runtime session.
diff --git a/src/luxonis_ml/embeddings/utils/model.py b/src/luxonis_ml/embeddings/utils/model.py
index 0cdbda45..4191a770 100644
--- a/src/luxonis_ml/embeddings/utils/model.py
+++ b/src/luxonis_ml/embeddings/utils/model.py
@@ -1,8 +1,7 @@
-"""
-Model Utility Functions
+"""Model Utility Functions.
 
 This script provides utility functions for handling pytorch models.
-It allows loading the model, exporting it to the ONNX format, 
+It allows loading the model, exporting it to the ONNX format,
 and manipulating ONNX models in order to extract intermediate outputs aka embeddings.
 
 Functions:
@@ -56,9 +55,8 @@
 
 
 def load_model_resnet50_minuslastlayer() -> nn.Module:
-    """
-    Load a pre-trained ResNet-50 model with the last fully connected layer removed.
-    """
+    """Load a pre-trained ResNet-50 model with the last fully connected layer
+    removed."""
     # model = models.resnet50(pretrained=True) # depricated
     model = models.resnet50(weights=resnet.ResNet50_Weights.IMAGENET1K_V1)
     model = nn.Sequential(
@@ -69,18 +67,14 @@ def load_model_resnet50_minuslastlayer() -> nn.Module:
 
 
 def load_model() -> nn.Module:
-    """
-    Load a pre-trained ResNet-50 model.
-    """
+    """Load a pre-trained ResNet-50 model."""
     model = models.resnet50(weights=resnet.ResNet50_Weights.IMAGENET1K_V1)
     model.eval()
     return model
 
 
 def export_model_onnx(model: nn.Module, model_path_out: str = "resnet50.onnx"):
-    """
-    Export the provided model to the ONNX format.
-    """
+    """Export the provided model to the ONNX format."""
     dummy_input = torch.randn(1, 3, 224, 224)
 
     torch.onnx.export(
@@ -97,18 +91,17 @@ def export_model_onnx(model: nn.Module, model_path_out: str = "resnet50.onnx"):
 
 
 def load_model_onnx(model_path: str = "resnet50.onnx") -> onnx.ModelProto:
-    """
-    Load an ONNX model from the provided path.
-    """
+    """Load an ONNX model from the provided path."""
     return onnx.load(model_path)
 
 
 def extend_output_onnx(
     onnx_model: onnx.ModelProto, intermediate_tensor_name: str
 ) -> onnx.ModelProto:
-    """
-    Set an intermediate output layer as output of the provided ONNX model.
-    (You need to know the name of the intermediate layer, which you can find by inspecting the ONNX model with Netron.app)
+    """Set an intermediate output layer as output of the provided ONNX model.
+
+    (You need to know the name of the intermediate layer, which you can
+    find by inspecting the ONNX model with Netron.app)
     """
     intermediate_layer_value_info = onnx.helper.ValueInfoProto()
     intermediate_layer_value_info.name = intermediate_tensor_name
@@ -119,9 +112,8 @@ def extend_output_onnx(
 def extend_output_onnx_overwrite(
     onnx_model: onnx.ModelProto, intermediate_tensor_name: str = "/Flatten_output_0"
 ) -> onnx.ModelProto:
-    """
-    Set the second to last layer ouput as output layer of the provided ONNX model, and rename it.
-    """
+    """Set the second to last layer ouput as output layer of the provided ONNX
+    model, and rename it."""
     onnx.checker.check_model(onnx_model)
     second_to_last_node = onnx_model.graph.node[-2]
     old_name = second_to_last_node.output[0]
diff --git a/src/luxonis_ml/embeddings/utils/qdrant.py b/src/luxonis_ml/embeddings/utils/qdrant.py
index 06584b76..04299cc5 100644
--- a/src/luxonis_ml/embeddings/utils/qdrant.py
+++ b/src/luxonis_ml/embeddings/utils/qdrant.py
@@ -1,5 +1,4 @@
-"""
-Qdrant Docker Management and Embedding Operations
+"""Qdrant Docker Management and Embedding Operations.
 
 This script provides a set of utility functions to manage Qdrant using Docker and perform various operations related to embeddings.
 
@@ -37,7 +36,8 @@
 
 
 class QdrantManager:
-    """Class to manage Qdrant Docker container and perform various operations related to embeddings."""
+    """Class to manage Qdrant Docker container and perform various operations
+    related to embeddings."""
 
     def __init__(self, image_name="qdrant/qdrant", container_name="qdrant_container"):
         """Initialize the QdrantManager."""
@@ -86,8 +86,7 @@ def is_container_running(self):
             return False
 
     def start_docker_qdrant(self):
-        """
-        Start the Qdrant Docker container.
+        """Start the Qdrant Docker container.
 
         NOTE: Make sure the user has the appropriate permissions to run Docker commands
             without sudo. Otherwise, the client_docker.images.pull() command will fail.
@@ -148,7 +147,7 @@ def create_collection(self, vector_size=512, distance=Distance.COSINE):
         try:
             self.client.get_collection(collection_name=self.collection_name)
             print("Collection already exists")
-        except Exception as e:
+        except Exception:
             self.client.recreate_collection(
                 collection_name=self.collection_name,
                 vectors_config=VectorParams(size=vector_size, distance=distance),
@@ -170,7 +169,8 @@ def insert_embeddings(self, embeddings, labels):
         )
 
     def insert_embeddings_nooverwrite(self, embeddings, labels):
-        """Insert embeddings and labels into a Qdrant collection only if they don't already exist (independent of the id)."""
+        """Insert embeddings and labels into a Qdrant collection only if they
+        don't already exist (independent of the id)."""
         # Create a list of search requests
         search_queries = [
             SearchRequest(
@@ -214,7 +214,8 @@ def insert_embeddings_nooverwrite(self, embeddings, labels):
         print("Inserted {} new embeddings".format(len(new_embeddings)))
 
     def batch_insert_embeddings(self, embeddings, labels, img_paths, batch_size=50):
-        """Batch insert embeddings, labels, and image paths into a Qdrant collection."""
+        """Batch insert embeddings, labels, and image paths into a Qdrant
+        collection."""
         total_len = len(embeddings)
 
         for i in range(0, total_len, batch_size):
@@ -237,7 +238,8 @@ def batch_insert_embeddings(self, embeddings, labels, img_paths, batch_size=50):
             self.client.upsert(collection_name=self.collection_name, points=batch)
 
     def batch_insert_embeddings_nooverwrite(self, embeddings, labels, batch_size=50):
-        """Batch insert embeddings and labels into a Qdrant collection, avoiding overwriting existing embeddings."""
+        """Batch insert embeddings and labels into a Qdrant collection,
+        avoiding overwriting existing embeddings."""
         total_len = len(embeddings)
 
         for i in range(0, total_len, batch_size):
@@ -310,7 +312,8 @@ def search_embeddings(self, embedding: np.ndarray, top=5):
         return search_results
 
     def search_embeddings_by_imagepath(self, embedding, image_path_part, top=5):
-        """Search for top similar embeddings in a Qdrant collection based on a partial image path."""
+        """Search for top similar embeddings in a Qdrant collection based on a
+        partial image path."""
         hits = self.client.search(
             collection_name=self.collection_name,
             query_vector=embedding.tolist(),
@@ -367,8 +370,8 @@ def get_similarities(self, reference_id, other_ids):
         return ids, scores
 
     def get_full_similarity_matrix(self, batch_size=100):
-        """
-        Compute a full similarity matrix for all embeddings in a Qdrant collection.
+        """Compute a full similarity matrix for all embeddings in a Qdrant
+        collection.
 
         NOTE: This method is not recommended for large collections.
             It is better to use the get_all_embeddings() method and compute the similarity matrix yourself.
@@ -412,8 +415,11 @@ def get_full_similarity_matrix(self, batch_size=100):
         return ids, sim_matrix
 
     def get_payloads_from_ids(self, ids):
-        """Retrieve payloads associated with a list of IDs from a Qdrant collection.
-        (The order of the payloads IS preserved.)"""
+        """Retrieve payloads associated with a list of IDs from a Qdrant
+        collection.
+
+        (The order of the payloads IS preserved.)
+        """
         # Retrieve the payloads for the given ids
         hits = self.client.retrieve(
             collection_name=self.collection_name,
@@ -432,8 +438,11 @@ def get_payloads_from_ids(self, ids):
         return payloads
 
     def get_embeddings_from_ids(self, ids):
-        """Retrieve embeddings associated with a list of IDs from a Qdrant collection.
-        (The order of the embeddings IS preserved.)"""
+        """Retrieve embeddings associated with a list of IDs from a Qdrant
+        collection.
+
+        (The order of the embeddings IS preserved.)
+        """
         # Retrieve the embeddings for the given ids
         hits = self.client.retrieve(
             collection_name=self.collection_name,
diff --git a/src/luxonis_ml/enums/__init__.py b/src/luxonis_ml/enums/__init__.py
index b02681c9..2e1e2dc5 100644
--- a/src/luxonis_ml/enums/__init__.py
+++ b/src/luxonis_ml/enums/__init__.py
@@ -1 +1,3 @@
-from .enums import *
+from .enums import LabelType
+
+__all__ = ["LabelType"]
diff --git a/src/luxonis_ml/luxonis_ml.py b/src/luxonis_ml/luxonis_ml.py
index 466a8b94..53716bf6 100644
--- a/src/luxonis_ml/luxonis_ml.py
+++ b/src/luxonis_ml/luxonis_ml.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 
-from luxonis_ml.data import *
 import argparse
 import os
 import json
@@ -46,8 +45,7 @@ def _config():
 
 
 def _dataset_sync(args):
-    with LuxonisDataset(args.team_id, args.dataset_id) as dataset:
-        dataset.sync_from_cloud()
+    raise NotImplementedError
 
 
 def _debug_performance(args):
@@ -87,9 +85,7 @@ def main():
     parser = argparse.ArgumentParser()
 
     subparsers = parser.add_subparsers(dest="main")
-    parser_config = subparsers.add_parser(
-        "config", help="Configure API keys for luxonis_ml"
-    )
+    subparsers.add_parser("config", help="Configure API keys for luxonis_ml")
     parser_dataset = subparsers.add_parser(
         "dataset", help="Dataset programs to work with LDF"
     )
diff --git a/src/luxonis_ml/scheme/v1/__init__.py b/src/luxonis_ml/scheme/v1/__init__.py
index 89b038fe..15586c23 100644
--- a/src/luxonis_ml/scheme/v1/__init__.py
+++ b/src/luxonis_ml/scheme/v1/__init__.py
@@ -1,2 +1,2 @@
-#from .archive_generator import ArchiveGenerator
-CONFIG_VERSION = "1.0"
\ No newline at end of file
+# from .archive_generator import ArchiveGenerator
+CONFIG_VERSION = "1.0"
diff --git a/src/luxonis_ml/scheme/v1/archive_generator.py b/src/luxonis_ml/scheme/v1/archive_generator.py
index e054adda..59b8f967 100644
--- a/src/luxonis_ml/scheme/v1/archive_generator.py
+++ b/src/luxonis_ml/scheme/v1/archive_generator.py
@@ -5,10 +5,10 @@
 import json
 from typing import List
 
+
 class ArchiveGenerator:
-    
-    """ 
-    Generator of abstracted NN archive (.tar) files containing config and model files (executables).
+    """Generator of abstracted NN archive (.tar) files containing config and
+    model files (executables).
 
     Attribures:
         archive_name (str): Desired archive file name.
@@ -16,38 +16,38 @@ class ArchiveGenerator:
         cfg_dict (dict): Archive configuration dict.
         executables_paths (list): Paths to relevant model executables.
     """
- 
+
     def __init__(
         self,
         archive_name: str,
         save_path: str,
         cfg_dict: dict,
         executables_paths: List[str],
-        ):
-        
-        self.archive_name = archive_name if archive_name.endswith(".tar.gz") else f"{archive_name}.tar.gz"
+    ):
+        self.archive_name = (
+            archive_name
+            if archive_name.endswith(".tar.gz")
+            else f"{archive_name}.tar.gz"
+        )
         self.mode = "w:gz"
 
         self.save_path = save_path
         self.executables_paths = executables_paths
-        
-        self.cfg = Config( # pydantic config check
-            config_version = cfg_dict["config_version"],
-            stages = cfg_dict["stages"]
+
+        self.cfg = Config(  # pydantic config check
+            config_version=cfg_dict["config_version"], stages=cfg_dict["stages"]
         )
-        
+
     def make_archive(self):
+        """Run NN archive (.tar) file generation."""
 
-        """
-        Run NN archive (.tar) file generation.
-        """
-        
         # create an in-memory file-like config object
         json_data, json_buffer = self._make_json()
 
         # construct .tar archive
-        with tarfile.open(os.path.join(self.save_path, self.archive_name), self.mode) as tar:
-
+        with tarfile.open(
+            os.path.join(self.save_path, self.archive_name), self.mode
+        ) as tar:
             # add executables
             for executable_path in self.executables_paths:
                 tar.add(executable_path, arcname=os.path.basename(executable_path))
@@ -58,21 +58,17 @@ def make_archive(self):
             json_buffer.seek(0)  # reset the buffer to the beginning
             tar.addfile(tarinfo, json_buffer)
 
-
     def _make_json(self):
+        """Create an in-memory config data file-like object."""
 
-        """
-        Create an in-memory config data file-like object.
-        """
-        
         # read-in config data as dict
         data = json.loads(self.cfg.model_dump_json())
 
         # create an in-memory file-like object
         json_buffer = BytesIO()
-        
+
         # encode the dictionary as bytes and write it to the in-memory file
-        json_data = json.dumps(data, indent=4).encode('utf-8')
+        json_data = json.dumps(data, indent=4).encode("utf-8")
         json_buffer.write(json_data)
 
-        return json_data, json_buffer
\ No newline at end of file
+        return json_data, json_buffer
diff --git a/src/luxonis_ml/scheme/v1/config.py b/src/luxonis_ml/scheme/v1/config.py
index 325182b1..2d6c3aa8 100644
--- a/src/luxonis_ml/scheme/v1/config.py
+++ b/src/luxonis_ml/scheme/v1/config.py
@@ -1,18 +1,20 @@
 from typing import List
 from pydantic import Field
-from config_building_blocks import *
+from .config_building_blocks import CustomBaseModel
 from model import Model
 from __init__ import CONFIG_VERSION
 
+
 class Config(CustomBaseModel):
-    """
-    The main class of the multi/single-stage model config scheme (multi-stage models consists of interconnected single-stage models).
+    """The main class of the multi/single-stage model config scheme (multi-
+    stage models consists of interconnected single-stage models).
 
     Attributes:
         config_version (str): Static variable representing the version of the config scheme.
         stages (list): List of Model objects each representing a stage in the model (list of one element for single-stage models).
         connections (list): List of connections instructing how to connect multi stage models (empty for single-stage models).
     """
+
     config_version: str = Field(CONFIG_VERSION, Literal=True)
     stages: List[Model]
-    connections: List = [] # TODO: To be implemented
\ No newline at end of file
+    connections: List = []  # TODO: To be implemented
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/__init__.py b/src/luxonis_ml/scheme/v1/config_building_blocks/__init__.py
index 08cfb907..229ebff1 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/__init__.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/__init__.py
@@ -1,5 +1,44 @@
-from .base_models.custom_base_model import CustomBaseModel
-from .base_models.metadata import Metadata
-from .base_models.input import Input
-from .base_models.output import Output
-from .base_models.head import Head
\ No newline at end of file
+from .base_models import (
+    CustomBaseModel,
+    HeadMetadataObjectDetectionYOLO,
+    HeadMetadata,
+    Head,
+    HeadMetadataSegmentation,
+    HeadMetadataClassification,
+    HeadMetadataObjectDetectionSSD,
+    HeadMetadataObjectDetection,
+    HeadMetadataKeypointDetection,
+    Input,
+    PreprocessingBlock,
+    Output,
+    Metadata,
+)
+from .enums import (
+    DataType,
+    Platform,
+    InputType,
+    ObjectDetectionSubtypeSSD,
+    ObjectDetectionSubtypeYOLO,
+)
+
+
+__all__ = [
+    "CustomBaseModel",
+    "HeadMetadataObjectDetectionYOLO",
+    "HeadMetadata",
+    "Head",
+    "HeadMetadataSegmentation",
+    "HeadMetadataClassification",
+    "HeadMetadataObjectDetectionSSD",
+    "HeadMetadataObjectDetection",
+    "HeadMetadataKeypointDetection",
+    "Input",
+    "PreprocessingBlock",
+    "Output",
+    "Metadata",
+    "DataType",
+    "Platform",
+    "InputType",
+    "ObjectDetectionSubtypeSSD",
+    "ObjectDetectionSubtypeYOLO",
+]
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/__init__.py b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/__init__.py
new file mode 100644
index 00000000..b9cfe868
--- /dev/null
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/__init__.py
@@ -0,0 +1,31 @@
+from .custom_base_model import CustomBaseModel
+from .head import (
+    HeadMetadataObjectDetectionYOLO,
+    HeadMetadata,
+    Head,
+    HeadMetadataSegmentation,
+    HeadMetadataClassification,
+    HeadMetadataObjectDetectionSSD,
+    HeadMetadataObjectDetection,
+    HeadMetadataKeypointDetection,
+)
+from .input import Input, PreprocessingBlock
+from .output import Output
+from .metadata import Metadata
+
+
+__all__ = [
+    "CustomBaseModel",
+    "HeadMetadataObjectDetectionYOLO",
+    "HeadMetadata",
+    "Head",
+    "HeadMetadataSegmentation",
+    "HeadMetadataClassification",
+    "HeadMetadataObjectDetectionSSD",
+    "HeadMetadataObjectDetection",
+    "HeadMetadataKeypointDetection",
+    "Input",
+    "PreprocessingBlock",
+    "Output",
+    "Metadata",
+]
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/custom_base_model.py b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/custom_base_model.py
index c47ee26c..f8057b44 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/custom_base_model.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/custom_base_model.py
@@ -1,5 +1,6 @@
 from pydantic import BaseModel, Extra
 
+
 class CustomBaseModel(BaseModel):
     class Config:
-        extra = Extra.forbid # forbid extra fields
\ No newline at end of file
+        extra = Extra.forbid  # forbid extra fields
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/head.py b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/head.py
index 6a36e358..b7e69dc0 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/head.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/head.py
@@ -1,31 +1,32 @@
 from pydantic import BaseModel, validator, Field
 from .custom_base_model import CustomBaseModel
 from typing import Optional, List, Union
-from ..enums import *
+from ..enums import ObjectDetectionSubtypeYOLO
 from abc import ABC
 
+
 class HeadMetadata(BaseModel, ABC):
-    """
-    Head metadata parent class.
-    
+    """Head metadata parent class.
+
     Attributes:
         family (str): Decoding family.
         classes (list): Names of object classes recognized by the model.
         n_classes (int): Number of object classes recognized by the model.
     """
+
     family: str
     classes: List[str]
     n_classes: int
 
 
 class HeadMetadataClassification(HeadMetadata):
-    """
-    Metadata for classification head.
-    
+    """Metadata for classification head.
+
     Attributes:
         family (str): Decoding family.
         is_softmax (bool): True, if output is already softmaxed.
     """
+
     family: str = Field("Classification", Literal=True)
     is_softmax: bool
 
@@ -33,14 +34,14 @@ class HeadMetadataClassification(HeadMetadata):
     def validate_label_type(
         cls,
         value,
-        ):
+    ):
         if value != "Classification":
             raise ValueError("Invalid family")
         return value
 
+
 class HeadMetadataObjectDetection(HeadMetadata, ABC):
-    """
-    Metadata for object detection head.
+    """Metadata for object detection head.
 
     Attributes:
         stride (int): Step size at which the filter (or kernel) moves across the input data during convolution.
@@ -48,14 +49,15 @@ class HeadMetadataObjectDetection(HeadMetadata, ABC):
         conf_threshold (float): Confidence score threshold above which a detected object is considered valid.
         max_det (int): Maximum detections per image.
     """
+
     stride: int
     iou_threshold: float
     conf_threshold: float
     max_det: int
 
+
 class HeadMetadataObjectDetectionYOLO(HeadMetadataObjectDetection):
-    """
-    Metadata for YOLO object detection head.
+    """Metadata for YOLO object detection head.
 
     Attributes:
         family (str): Decoding family.
@@ -64,29 +66,31 @@ class HeadMetadataObjectDetectionYOLO(HeadMetadataObjectDetection):
         n_prototypes (int): Number of prototypes per bbox if provided.
         prototype_output_name (str): Output node containing prototype information.
     """
-    family: str = Field("ObjectDetectionYOLO", Literal=True) 
+
+    family: str = Field("ObjectDetectionYOLO", Literal=True)
     subtype: ObjectDetectionSubtypeYOLO
     n_keypoints: Optional[int] = None
     n_prototypes: Optional[int] = None
     prototype_output_name: Optional[str] = None
-    
+
     @validator("family")
     def validate_label_type(
         cls,
         value,
-        ):
+    ):
         if value != "ObjectDetectionYOLO":
             raise ValueError("Invalid family")
         return value
-    
+
+
 class HeadMetadataObjectDetectionSSD(HeadMetadataObjectDetection):
-    """
-    Metadata for SSD object detection head.
+    """Metadata for SSD object detection head.
 
     Attributes:
         family (str): Decoding family.
         anchors (list): Predefined bounding boxes of different sizes and aspect ratios.
     """
+
     family: str = Field("ObjectDetectionSSD", Literal=True)
     anchors: Optional[List[List[int]]] = None
 
@@ -94,19 +98,20 @@ class HeadMetadataObjectDetectionSSD(HeadMetadataObjectDetection):
     def validate_label_type(
         cls,
         value,
-        ):
+    ):
         if value != "ObjectDetectionSSD":
             raise ValueError("Invalid family")
         return value
 
+
 class HeadMetadataSegmentation(HeadMetadata):
-    """
-    Metadata for segmentation head. 
-    
+    """Metadata for segmentation head.
+
     Attributes:
         family (str): Decoding family.
         is_softmax (bool): True, if output is already softmaxed.
     """
+
     family: str = Field("Segmentation", Literal=True)
     is_softmax: bool
 
@@ -114,31 +119,32 @@ class HeadMetadataSegmentation(HeadMetadata):
     def validate_label_type(
         cls,
         value,
-        ):
+    ):
         if value != "Segmentation":
             raise ValueError("Invalid family")
         return value
 
+
 class HeadMetadataKeypointDetection(HeadMetadata):
-    """
-    Metadata for keypoint detection head.
-    """
+    """Metadata for keypoint detection head."""
+
     def __init__(self):
         raise NotImplementedError
 
+
 class Head(CustomBaseModel):
-    """
-    Represents head of a model.
+    """Represents head of a model.
 
     Attributes:
         head_id (str): Unique head identifier.
         metadata: (HeadMetadata object): Parameters required by head to run postprocessing.
     """
+
     head_id: str
     metadata: Union[
         HeadMetadataObjectDetectionYOLO,
         HeadMetadataObjectDetectionSSD,
         HeadMetadataSegmentation,
         HeadMetadataClassification,
-        #HeadMetadataKeypointDetection, # TODO
-        ]
\ No newline at end of file
+        # HeadMetadataKeypointDetection, # TODO
+    ]
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/input.py b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/input.py
index db47f281..2db3bb87 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/input.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/input.py
@@ -1,27 +1,28 @@
 from pydantic import Field
 from .custom_base_model import CustomBaseModel
-from typing import Optional, List, Annotated
-from ..enums import *
+from typing import Optional, List
+from typing_extensions import Annotated
+from ..enums import DataType, InputType
+
 
 class PreprocessingBlock(CustomBaseModel):
-    """
-    Represents preprocessing operations applied to the input data.
-    
+    """Represents preprocessing operations applied to the input data.
+
     Attributes:
         mean (list): Mean values in BGR order.
         scale (list): Standardization values in BGR order.
         reverse_channels (bool): If True, color channels are reversed (e.g. BGR to RGB or vice versa).
         interleaved_to_planar (bool): If True, format is changed from interleaved to planar.
     """
-    
+
     mean: Optional[List[float]] = None
     scale: Optional[List[float]] = None
     reverse_channels: Optional[bool] = False
     interleaved_to_planar: Optional[bool] = False
 
+
 class Input(CustomBaseModel):
-    """
-    Represents input stream of a model.
+    """Represents input stream of a model.
 
     Attributes:
         name (str): Name of the input layer.
@@ -30,8 +31,9 @@ class Input(CustomBaseModel):
         shape (list): Shape of the input data as a list of integers (e.g. [H,W], [H,W,C], [BS,H,W,C], ...).
         preprocessing (PreprocessingBlock): Preprocessing steps applied to the input data.
     """
+
     name: str
     dtype: DataType
     input_type: InputType
     shape: Annotated[List[int], Field(min_length=1, max_length=5)]
-    preprocessing: PreprocessingBlock
\ No newline at end of file
+    preprocessing: PreprocessingBlock
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/metadata.py b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/metadata.py
index 73c35bcf..29dfec87 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/metadata.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/metadata.py
@@ -1,14 +1,14 @@
 from pydantic import BaseModel
-from ..enums import *
+from ..enums import Platform
+
 
 class Metadata(BaseModel):
-    """
-    Represents metadata of a model.
+    """Represents metadata of a model.
 
     Attributes:
         name (str): Name of the model.
         platform (Platform): Luxonis hardware platform for which the model was exported (e.g. 'rvc4').
-
     """
+
     name: str
-    platform: Platform
\ No newline at end of file
+    platform: Platform
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/output.py b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/output.py
index b87a8200..7d1294d7 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/output.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/base_models/output.py
@@ -1,16 +1,17 @@
 from .custom_base_model import CustomBaseModel
 from typing import List
-from ..enums import *
+from ..enums import DataType
+
 
 class Output(CustomBaseModel):
-    """
-    Represents output stream of a model.
+    """Represents output stream of a model.
 
     Attributes:
         name (str): Name of the output layer.
         dtype (DataType): Data type of the output data (e.g., 'float32').
         head_ids (list): IDs of heads which accept this output stream (beware that a single output can go into multiple heads).
     """
+
     name: str
     dtype: DataType
-    head_ids: List[str]
\ No newline at end of file
+    head_ids: List[str]
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/__init__.py b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/__init__.py
index 9519cf4c..aa52b6ea 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/__init__.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/__init__.py
@@ -1,4 +1,13 @@
 from .data_type import DataType
-from .input_type import InputType
 from .platform import Platform
-from .decoding import ObjectDetectionSubtypeYOLO, ObjectDetectionSubtypeSSD
\ No newline at end of file
+from .input_type import InputType
+from .decoding import ObjectDetectionSubtypeSSD, ObjectDetectionSubtypeYOLO
+
+
+__all__ = [
+    "DataType",
+    "Platform",
+    "InputType",
+    "ObjectDetectionSubtypeSSD",
+    "ObjectDetectionSubtypeYOLO",
+]
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/data_type.py b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/data_type.py
index 452ec978..81e89299 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/data_type.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/data_type.py
@@ -1,12 +1,10 @@
 from enum import Enum
 
-class DataType(Enum):
 
-    """ 
-    Represents all existing data types used in i/o streams of the model.
-    """
+class DataType(Enum):
+    """Represents all existing data types used in i/o streams of the model."""
 
     INT8 = "int8"
     UINT8 = "uint8"
     FLOAT32 = "float32"
-    FLOAT16 = "float16"
\ No newline at end of file
+    FLOAT16 = "float16"
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/decoding.py b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/decoding.py
index afbaebd4..a31d9f10 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/decoding.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/decoding.py
@@ -1,9 +1,10 @@
 from enum import Enum
 
+
 class ObjectDetectionSubtypeYOLO(Enum):
+    """Object detection decoding subtypes for YOLO networks.
 
-    """ 
-    Object detection decoding subtypes for YOLO networks. Subtype members have exactly the same decoding. 
+    Subtype members have exactly the same decoding.
     """
 
     YOLOv5 = "yolov5"
@@ -13,9 +14,9 @@ class ObjectDetectionSubtypeYOLO(Enum):
 
 
 class ObjectDetectionSubtypeSSD(Enum):
+    """Object detection decoding subtypes for SSD networks.
 
-    """ 
-    Object detection decoding subtypes for SSD networks. Subtype members have exactly the same decoding. 
+    Subtype members have exactly the same decoding.
     """
 
-    SSD_PARSED = "ssd-parsed"
\ No newline at end of file
+    SSD_PARSED = "ssd-parsed"
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/input_type.py b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/input_type.py
index bbff08ec..943b24f7 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/input_type.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/input_type.py
@@ -1,10 +1,8 @@
 from enum import Enum
 
-class InputType(Enum):
 
-    """ 
-    Represents a type of input the model is expecting.
-    """
+class InputType(Enum):
+    """Represents a type of input the model is expecting."""
 
     RAW = "raw"
-    IMAGE = "image"
\ No newline at end of file
+    IMAGE = "image"
diff --git a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/platform.py b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/platform.py
index 955f3f8f..073fbcc6 100644
--- a/src/luxonis_ml/scheme/v1/config_building_blocks/enums/platform.py
+++ b/src/luxonis_ml/scheme/v1/config_building_blocks/enums/platform.py
@@ -1,10 +1,10 @@
 from enum import Enum
 
+
 class Platform(Enum):
-    """ 
-    Represents existing Luxonis hardware platforms. 
-    """
+    """Represents existing Luxonis hardware platforms."""
+
     HAILO = "hailo"
     RVC2 = "rvc2"
     RVC3 = "rvc3"
-    RVC4 = "rvc4"
\ No newline at end of file
+    RVC4 = "rvc4"
diff --git a/src/luxonis_ml/scheme/v1/model.py b/src/luxonis_ml/scheme/v1/model.py
index b7ac9aaa..20ad673c 100644
--- a/src/luxonis_ml/scheme/v1/model.py
+++ b/src/luxonis_ml/scheme/v1/model.py
@@ -1,9 +1,9 @@
 from typing import List
-from config_building_blocks import *
+from config_building_blocks import Metadata, Input, Output, Head, CustomBaseModel
+
 
 class Model(CustomBaseModel):
-    """
-    Class defining a single-stage model config scheme.
+    """Class defining a single-stage model config scheme.
 
     Attributes:
         metadata (Metadata): Metadata object defining the model metadata.
@@ -11,7 +11,8 @@ class Model(CustomBaseModel):
         outputs (list): List of Output objects defining the model outputs.
         heads: (list): List of Head objects defining the model heads.
     """
+
     metadata: Metadata
     inputs: List[Input]
     outputs: List[Output]
-    heads: List[Head]
\ No newline at end of file
+    heads: List[Head]
diff --git a/src/luxonis_ml/tracker/mlflow_plugins.py b/src/luxonis_ml/tracker/mlflow_plugins.py
index 49cc9357..a54b39ea 100644
--- a/src/luxonis_ml/tracker/mlflow_plugins.py
+++ b/src/luxonis_ml/tracker/mlflow_plugins.py
@@ -1,4 +1,3 @@
-import os
 from mlflow import __version__
 from mlflow.tracking.request_header.abstract_request_header_provider import (
     RequestHeaderProvider,
diff --git a/src/luxonis_ml/tracker/tracker.py b/src/luxonis_ml/tracker/tracker.py
index 897c4a5e..c5e4ca7f 100644
--- a/src/luxonis_ml/tracker/tracker.py
+++ b/src/luxonis_ml/tracker/tracker.py
@@ -23,7 +23,8 @@ def __init__(
         mlflow_tracking_uri: Optional[str] = None,
         rank: int = 0,
     ):
-        """Implementation of PytorchLightning Logger that wraps various logging software. Supported loggers: TensorBoard, WandB and MLFlow
+        """Implementation of PytorchLightning Logger that wraps various logging
+        software. Supported loggers: TensorBoard, WandB and MLFlow.
 
         Args:
             project_name (Optional[str], optional): Name of the project used for WandB and MLFlow. Defaults to None.
@@ -82,8 +83,9 @@ def __init__(
             parents=True, exist_ok=True
         )
 
+    @staticmethod
     def rank_zero_only(fn: Callable) -> Callable:
-        """Function wrapper that lets only processes with rank=0 execute it"""
+        """Function wrapper that lets only processes with rank=0 execute it."""
 
         @wraps(fn)
         def wrapped_fn(self, *args: Any, **kwargs: Any) -> Optional[Any]:
@@ -95,18 +97,19 @@ def wrapped_fn(self, *args: Any, **kwargs: Any) -> Optional[Any]:
 
     @property
     def name(self) -> str:
-        """Returns run name"""
+        """Returns run name."""
         return self.run_name
 
     @property
     def version(self) -> int:
-        """Returns tracker's version"""
+        """Returns tracker's version."""
         return 1
 
     @property
     @rank_zero_only
     def experiment(self) -> Dict[str, Any]:
-        """Creates new experiments or returns active ones if already created"""
+        """Creates new experiments or returns active ones if already
+        created."""
         if self._experiment is not None:
             return self._experiment
 
@@ -128,7 +131,7 @@ def experiment(self) -> Dict[str, Any]:
 
             self._experiment["wandb"].init(
                 project=self.project_name
-                if self.project_name != None
+                if self.project_name is not None
                 else self.project_id,
                 entity=self.wandb_entity,
                 dir=log_dir,
@@ -164,7 +167,7 @@ def experiment(self) -> Dict[str, Any]:
     def log_hyperparams(
         self, params: Dict[str, Union[str, bool, int, float, None]]
     ) -> None:
-        """Logs hyperparameter dictionary
+        """Logs hyperparameter dictionary.
 
         Args:
             params (Dict[str, Union[str, bool, int, float, None]]): Dict of hyperparameters key-value pairs
@@ -183,8 +186,8 @@ def log_hyperparams(
 
     @rank_zero_only
     def log_metric(self, name: str, value: float, step: int) -> None:
-        """Logs metric value with name and step. Note: step is ommited when logging
-        with wandb to avoid problems with inconsistent incrementation.
+        """Logs metric value with name and step. Note: step is ommited when
+        logging with wandb to avoid problems with inconsistent incrementation.
 
         Args:
             name (str): Metric name
@@ -203,7 +206,7 @@ def log_metric(self, name: str, value: float, step: int) -> None:
 
     @rank_zero_only
     def log_metrics(self, metrics: Dict[str, float], step: int) -> None:
-        """Logs metric dictionary
+        """Logs metric dictionary.
 
         Args:
             metrics (Dict[str, float]): Dict of metric key-value pairs
@@ -244,7 +247,7 @@ def log_image(self, name: str, img: np.ndarray, step: int) -> None:
 
     @rank_zero_only
     def log_images(self, imgs: Dict[str, np.ndarray], step: int) -> None:
-        """Logs multiple images
+        """Logs multiple images.
 
         Args:
             imgs (Dict[str, np.ndarray]): Dict of image key-value pairs where key is image caption and value is image data
@@ -254,7 +257,7 @@ def log_images(self, imgs: Dict[str, np.ndarray], step: int) -> None:
             self.log_image(caption, img, step)
 
     def _get_next_run_number(self) -> int:
-        """Returns number id for next run"""
+        """Returns number id for next run."""
         # find all directories that should be runs
         log_dirs = glob.glob(f"{self.save_directory}/*")
         log_dirs = [path.split("/")[-1] for path in log_dirs if os.path.isdir(path)]
@@ -268,22 +271,22 @@ def _get_next_run_number(self) -> int:
             return max(nums) + 1
 
     def _get_run_name(self) -> str:
-        """Generates new run name"""
+        """Generates new run name."""
         name_without_number = get_random_name(separator="-", style="lowercase")
         number = self._get_next_run_number()
         return f"{number}-{name_without_number}"
 
     def _get_latest_run_name(self) -> str:
-        """Returns most recently created run name"""
+        """Returns most recently created run name."""
         # find all directories that should be runs
         log_dirs = glob.glob(f"{self.save_directory}/*")
         log_dirs = [path for path in log_dirs if os.path.isdir(path)]
         # find run names based on the naming convention and sort them by last modified time
         runs = []
-        for l in log_dirs:
-            l = l.replace(f"{self.save_directory}/", "")
-            if l.split("-")[0].isnumeric():
-                runs.append(l)
+        for ld in log_dirs:
+            ld = ld.replace(f"{self.save_directory}/", "")
+            if ld.split("-")[0].isnumeric():
+                runs.append(ld)
         runs.sort(
             key=lambda x: os.path.getmtime(os.path.join(self.save_directory, x)),
             reverse=True,
diff --git a/src/luxonis_ml/utils/config.py b/src/luxonis_ml/utils/config.py
index 76715d34..9b62a9b3 100644
--- a/src/luxonis_ml/utils/config.py
+++ b/src/luxonis_ml/utils/config.py
@@ -17,7 +17,6 @@ class LuxonisConfig(BaseModel):
     Note:
         Only the `get_config` method can be used to instantiate this class.
         Using `__init__` directly will raise a `NotImplementedError`.
-
     """
 
     model_config = ConfigDict(extra="forbid")
@@ -102,16 +101,17 @@ def __repr__(self) -> str:
 
     @classmethod
     def clear_instance(cls) -> None:
-        """Clears all singleton instances, should be only used for unit-testing"""
+        """Clears all singleton instances, should be only used for unit-
+        testing."""
         cls._instance = None
         cls._from_get_config = False
 
     def get_json_schema(self) -> Dict[str, Any]:
-        """Retuns dict representation of config json schema"""
+        """Retuns dict representation of config json schema."""
         return self.model_json_schema(mode="validation")
 
     def save_data(self, path: str) -> None:
-        """Saves config to yaml file
+        """Saves config to yaml file.
 
         Args:
             path (str): Path to output yaml file
diff --git a/src/luxonis_ml/utils/filesystem.py b/src/luxonis_ml/utils/filesystem.py
index 200f2f1e..3007905c 100644
--- a/src/luxonis_ml/utils/filesystem.py
+++ b/src/luxonis_ml/utils/filesystem.py
@@ -19,8 +19,8 @@ def __init__(
         allow_local: Optional[bool] = True,
         cache_storage: Optional[str] = None,
     ):
-        """Helper class which abstracts uploading and downloading files from remote and local sources.
-        Supports S3, MLflow and local file systems.
+        """Helper class which abstracts uploading and downloading files from
+        remote and local sources. Supports S3, MLflow and local file systems.
 
         Args:
             path (str): Input path consisting of protocol and actual path or just path for local files
@@ -77,7 +77,7 @@ def __init__(
             self.fs = self.init_fsspec_filesystem()
 
     def full_path(self) -> str:
-        """Returns full path"""
+        """Returns full path."""
         return f"{self.protocol}://{self.path}"
 
     def init_fsspec_filesystem(self) -> Any:
@@ -112,7 +112,7 @@ def put_file(
         remote_path: str,
         mlflow_instance: Optional[ModuleType] = None,
     ) -> None:
-        """Copy single file to remote
+        """Copy single file to remote.
 
         Args:
             local_path (str): Path to local file
@@ -181,7 +181,7 @@ def put_bytes(
         remote_path: str,
         mlflow_instance: Optional[ModuleType] = None,
     ) -> None:
-        """Uploads a file to remote storage directly from file bytes
+        """Uploads a file to remote storage directly from file bytes.
 
         Args:
             file_bytes (bytes): the bytes for the file contents
@@ -201,7 +201,7 @@ def get_file(
         local_path: str,
         mlflow_instance: Optional[ModuleType] = None,
     ) -> None:
-        """Copy a single file from remote
+        """Copy a single file from remote.
 
         Args:
             remote_path (str): Relative path to remote file
@@ -237,7 +237,8 @@ def get_dir(
             )
 
     def walk_dir(self, remote_dir: str) -> Generator[str, None, None]:
-        """Recursively walks through the individual files in a remote directory"""
+        """Recursively walks through the individual files in a remote
+        directory."""
 
         if self.is_mlflow:
             raise NotImplementedError
@@ -251,7 +252,7 @@ def walk_dir(self, remote_dir: str) -> Generator[str, None, None]:
                     yield os.path.relpath(file, self.path)
 
     def read_to_byte_buffer(self, remote_path: Optional[str] = None) -> BytesIO:
-        """Reads a file and returns Byte buffer
+        """Reads a file and returns Byte buffer.
 
         Args:
             remote_path (Optional[str]): If provided, the relative path to the remote file
@@ -286,7 +287,8 @@ def read_to_byte_buffer(self, remote_path: Optional[str] = None) -> BytesIO:
         return buffer
 
     def get_file_uuid(self, path: str, local: bool = False) -> str:
-        """Reads a file and returns the (unique) UUID generated from file bytes
+        """Reads a file and returns the (unique) UUID generated from file
+        bytes.
 
         Args:
             path (str): If remote, relative path to the remote file. Else the local path
@@ -329,7 +331,7 @@ def get_file_uuids(self, paths: List[str], local: bool = False) -> Dict[str, str
         return result
 
     def _split_mlflow_path(self, path: str) -> List[Optional[str]]:
-        """Splits mlflow path into 3 parts"""
+        """Splits mlflow path into 3 parts."""
         parts = path.split("/")
         if len(parts) < 3:
             while len(parts) < 3:
@@ -340,7 +342,7 @@ def _split_mlflow_path(self, path: str) -> List[Optional[str]]:
         return parts
 
     def is_directory(self, remote_path: str) -> bool:
-        """Returns True if a remote path points to a directory"""
+        """Returns True if a remote path points to a directory."""
 
         full_path = os.path.join(self.path, remote_path)
         file_info = self.fs.info(full_path)
@@ -351,20 +353,21 @@ def is_directory(self, remote_path: str) -> bool:
 
     @staticmethod
     def split_full_path(path: str) -> Tuple[str, str]:
-        """Returns a tuple for the absolute and relative path given a full path"""
+        """Returns a tuple for the absolute and relative path given a full
+        path."""
 
         path = path.rstrip("/\\")
         return os.path.split(path)
 
     @staticmethod
     def get_protocol(path: str) -> str:
-        """Gets the detected protocol of a path"""
+        """Gets the detected protocol of a path."""
 
         return _get_protocol_and_path(path)[0]
 
 
 def _get_protocol_and_path(path: str) -> Tuple[str, str]:
-    """Gets the protocol and absolute path of a full path"""
+    """Gets the protocol and absolute path of a full path."""
 
     if "://" in path:
         protocol, path = path.split("://")
diff --git a/src/luxonis_ml/utils/registry.py b/src/luxonis_ml/utils/registry.py
index 93299038..d5cf9eca 100644
--- a/src/luxonis_ml/utils/registry.py
+++ b/src/luxonis_ml/utils/registry.py
@@ -6,7 +6,6 @@ class Registry:
     def __init__(self, name: str):
         """A registry to map strings to classes or functions.
 
-
         Args:
             name (str): Registry name
         """
@@ -31,7 +30,7 @@ def module_dict(self):
         return self._module_dict
 
     def get(self, key: str) -> type:
-        """Get the registry record for the key
+        """Get the registry record for the key.
 
         Args:
             key (str): Name of the registered item, e.g. the class name in string format
@@ -51,7 +50,7 @@ def register_module(
         module: Optional[type] = None,
         force: bool = False,
     ) -> Union[type, Callable[[type], type]]:
-        """Registers a module
+        """Registers a module.
 
         Args:
             name (Optional[str], optional): Name of the module, if None then use class name. Defaults to None.
@@ -76,7 +75,7 @@ def _register(module: type) -> type:
     def _register_module(
         self, module: type, module_name: Optional[str] = None, force: bool = False
     ) -> None:
-        """Registers a module by creating a (key, value) pair
+        """Registers a module by creating a (key, value) pair.
 
         Args:
             module (type): Module class to be registered
@@ -153,7 +152,5 @@ def __new__(
                 )
         if register:
             registry = registry if registry is not None else new_class.REGISTRY
-            registry.register_module(
-                name=register_name or name, module=new_class
-            )
+            registry.register_module(name=register_name or name, module=new_class)
         return new_class
diff --git a/tests/test_utils/test_config.py b/tests/test_utils/test_config.py
index a2307b9f..7a464f37 100644
--- a/tests/test_utils/test_config.py
+++ b/tests/test_utils/test_config.py
@@ -241,6 +241,7 @@ def test_save(config_file: str):
     assert cfg.__repr__() == cfg2.__repr__()
     assert cfg.get_json_schema() == cfg2.get_json_schema()
 
+
 def test_get(config_file: str):
     cfg = Config.get_config(
         config_file,
diff --git a/tests/test_utils/test_filesystem.py b/tests/test_utils/test_filesystem.py
index 4e00fbc8..e805a270 100644
--- a/tests/test_utils/test_filesystem.py
+++ b/tests/test_utils/test_filesystem.py
@@ -13,6 +13,3 @@ def test_protocol():
 
     with pytest.raises(ValueError):
         LuxonisFileSystem("foo://bar")
-
-
-