dsa-helpers 0.3.dev1__tar.gz → 0.4.dev0__tar.gz

{dsa_helpers-0.3.dev1 → dsa_helpers-0.4.dev0}/.gitignore

@@ -7,4 +7,5 @@ dsa_utils/_version.py
 
 *.pyc
 *.egg-info
-dist/
+dist/
+.env

{dsa_helpers-0.3.dev1/dsa_helpers.egg-info → dsa_helpers-0.4.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dsa_helpers
-Version: 0.3.dev1
+Version: 0.4.dev0
 Summary: Utility functions for working with the DSA girder client.
 Author-email: "Juan C. Vizcarra" <jvizcar@emory.edu>
 Maintainer-email: "Juan C. Vizcarra" <jvizcar@emory.edu>
@@ -20,6 +20,8 @@ Requires-Dist: pymongo
 Requires-Dist: pillow
 Requires-Dist: dash
 Requires-Dist: dash_bootstrap_components
+Requires-Dist: shapely
+Requires-Dist: geopandas
 
 # Digital Slide Archive (DSA) Helpers
 Digital Slide Archive Python utility library.
@@ -27,3 +29,16 @@ Digital Slide Archive Python utility library.
 This library is available for installation through [Python Package Index (PyPI)](https://pypi.org/).
 
 This library was tested using Python version 3.11.8 and uses the dependencies described in requirements.txt.
+
+This Python PyPI package is found [here](https://pypi.org/project/dsa-helpers/).
+
+## Instructions for Development
+1. Install requirements for building and distributing package:
+```
+$ python3 -m pip install --upgrade build  # for building package
+$ python3 -m pip install --upgrade build  # for uploading to PyPI
+```
+2. When ready to build:
+    - Modify "pyproject.toml" file, change the "version" key to a different value than a version already pushed.
+    - Run ```$ python3 -m build```. This will create a dist directory and put your new wheel and tar distribution files there.
+3. To install locally for development: ```$ pip3 install dist/dsa_helpers-*.whl```, choosing the wheel version you want to test.

dsa_helpers-0.4.dev0/README.md

@@ -0,0 +1,19 @@
+# Digital Slide Archive (DSA) Helpers
+Digital Slide Archive Python utility library.
+
+This library is available for installation through [Python Package Index (PyPI)](https://pypi.org/).
+
+This library was tested using Python version 3.11.8 and uses the dependencies described in requirements.txt.
+
+This Python PyPI package is found [here](https://pypi.org/project/dsa-helpers/).
+
+## Instructions for Development
+1. Install requirements for building and distributing package:
+```
+$ python3 -m pip install --upgrade build  # for building package
+$ python3 -m pip install --upgrade build  # for uploading to PyPI
+```
+2. When ready to build:
+    - Modify "pyproject.toml" file, change the "version" key to a different value than a version already pushed.
+    - Run ```$ python3 -m build```. This will create a dist directory and put your new wheel and tar distribution files there.
+3. To install locally for development: ```$ pip3 install dist/dsa_helpers-*.whl```, choosing the wheel version you want to test.

dsa_helpers-0.4.dev0/app.py

@@ -0,0 +1,14 @@
+# A test application.
+from dash import Dash, html
+import dash_bootstrap_components as dbc
+from dsa_helpers.dash.header import get_header
+import os
+
+os.environ["DSA_API_URL"] = "https://megabrain.neurology.emory.edu/api/v1"
+
+app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
+
+app.layout = html.Div([get_header("Test")])
+
+if __name__ == "__main__":
+    app.run_server(debug=True)

{dsa_helpers-0.3.dev1 → dsa_helpers-0.4.dev0}/dsa_helpers/__init__.py

@@ -1,7 +1,8 @@
 # Shadow imports.
-from .login import login
 from .imread import imread
 from .imwrite import imwrite
 
 # Modules that should be available.
-from . import girder_utils, image_utils, dash
+# from . import girder_utils, image_utils, dash
+
+__all__ = ["girder_utils", "image_utils", "dash"]

{dsa_helpers-0.3.dev1 → dsa_helpers-0.4.dev0}/dsa_helpers/girder_utils.py

@@ -1,5 +1,5 @@
 # Functions using the girder client.
-from girder_client import GirderClient
+from girder_client import GirderClient, HttpError
 import pickle
 import numpy as np
 import pandas as pd
@@ -285,3 +285,62 @@ def get_rectangle_element_coords(element):
     corner_coords = np.array(corner_coords, dtype=np.int32)
 
     return corner_coords
+
+
+def login(
+    api_url: str,
+    login_or_email: str | None = None,
+    password: str | None = None,
+    api_key: str | None = None,
+) -> GirderClient:
+    """Authenticate a girder client with the given credentials or interactively
+    if none is given.
+
+    Args:
+        api_url (str): The DSA girder API url.
+        login_or_email (str | None): The login or email. Defaults to None.
+        password (str | None): Password for login / email. Defaults to None.
+        api_key (str | None): The api key to authenticate with. Defaults to None.
+
+    Returns:
+        girder_client.GirderClient: The authenticated girder client.
+
+    """
+    gc = GirderClient(apiUrl=api_url)
+
+    if api_key is None:
+        if login_or_email is None:
+            _ = gc.authenticate(interactive=True)
+        elif password is None:
+            _ = gc.authenticate(username=login_or_email, interactive=True)
+        else:
+            _ = gc.authenticate(username=login_or_email, password=password)
+    else:
+        _ = gc.authenticate(apiKey=api_key)
+
+    return gc
+
+
+def get_items(gc: GirderClient, parend_id: str) -> list[dict]:
+    """Get the items in a parent location recursively.
+
+    Args:
+        gc (girder_client.GirderClient): The authenticated girder client.
+        parend_id (str): The parent id to start the search (folder / collection).
+
+    Returns:
+        list[dict]: The list of items.
+
+    """
+    params = {"type": "folder", "limit": 0, "offset": 0, "sort": "_id", "sortdir": 1}
+
+    request_url = f"resource/{parend_id}/items"
+
+    try:
+        items = gc.get(request_url, parameters=params)
+    except HttpError:
+        params["type"] = "collection"
+
+        items = gc.get(request_url, parameters=params)
+
+    return items

dsa_helpers-0.4.dev0/dsa_helpers/ml/__init__.py

@@ -0,0 +1,2 @@
+# Modules that can be imported.
+__all__ = ["object_detection"]

dsa_helpers-0.4.dev0/dsa_helpers/ml/object_detection/__init__.py

@@ -0,0 +1,5 @@
+# Shadow import functions.
+from .get_pearce_roi_images import get_pearce_roi_images
+from .tile_image import tile_image
+
+__all__ = ["utils"]

dsa_helpers-0.4.dev0/dsa_helpers/ml/object_detection/get_pearce_roi_images.py

@@ -0,0 +1,136 @@
+from girder_client import GirderClient
+import pandas as pd
+from pathlib import Path
+
+from ...girder_utils import get_region, get_item_large_image_metadata
+from ... import imwrite
+
+
+def get_pearce_roi_images(
+    gc: GirderClient,
+    item_id: str,
+    class_map: dict[str, int],
+    save_dir: str = ".",
+    mag: float | None = None,
+) -> pd.DataFrame:
+    """Download the smallestl bounding box around an ROI annotations and its
+    accompanying object detection annotations. The format used to determine ROIs
+    and boxes is based on the convention used by Dr. Thomas Pearce in his
+    OpenSeadragon applications. Labels are saved as text files in the YOLO format.
+
+    Args:
+        gc (girder_client.GirderClient): The Girder client to use.
+        item_id (str): The item ID of the WSI.
+        class_map (dict[str, int]): A dictionary mapping class names to integers.
+        save_dir (str, optional): The directory to save the images and labels.
+            Defaults to ".".
+        mag (float | None, optional): The magnification to download the ROI at.
+            If None, the scan magnification is used. Defaults to None.
+
+    Returns:
+        pandas.DataFrame: A DataFrame containing metadata for each ROI
+
+    """
+    # Create directories to save images and labels.
+    img_dir = Path(save_dir) / "images"
+    img_dir.mkdir(parents=True, exist_ok=True)
+
+    label_dir = Path(save_dir) / "labels"
+    label_dir.mkdir(parents=True, exist_ok=True)
+
+    # Get all the annotation documents with name starting with "ROI".
+    ann_docs_ids = []
+
+    for ann_doc in gc.get(
+        f"annotation?itemId={item_id}&limit=0&offset=0&sort=lowerName&sortdir=1"
+    ):
+        if ann_doc.get("annotation", {}).get("name", "").startswith("ROI"):
+            ann_docs_ids.append(ann_doc["_id"])
+
+    if not len(ann_docs_ids):
+        # No annotation documents, return None.
+        return
+
+    # Track metadata for each ROI.
+    roi_metadata = []
+
+    # Loop through each document.
+    for ann_doc_id in ann_docs_ids:
+        # Get the full annotation document.
+        ann_doc = gc.get(f"annotation/{ann_doc_id}")
+
+        # Separate the ROI element and the other elements.
+        roi_el = None
+        other_els = []
+
+        for element in ann_doc.get("annotation", {}).get("elements", []):
+            if element.get("user", {}).get("role") == "ROI":
+                roi_el = element
+            else:
+                other_els.append(element)
+
+        if roi_el is None:
+            raise Exception("No ROI element found in annotation document.")
+
+        # Download the ROI image.
+        xc, yc = roi_el["center"][:2]
+        roi_w, roi_h = int(roi_el["width"]), int(roi_el["height"])
+
+        # Get the top left coordinate of the ROI.
+        roi_left = int(xc - roi_w / 2)
+        roi_top = int(yc - roi_h / 2)
+
+        # Get scale factor to go from scan magnification to mag.
+        scan_mag = get_item_large_image_metadata(gc, item_id)["magnification"]
+
+        if mag is None:
+            mag = scan_mag
+
+        roi_img = get_region(
+            gc, item_id, left=roi_left, top=roi_top, width=roi_w, height=roi_h, mag=mag
+        )
+
+        fn = f"itemId-{item_id}-x{roi_left}y{roi_top}x{roi_left+roi_w}y{roi_top+roi_h}"
+
+        img_fp = img_dir / f"{fn}.png"
+        imwrite(img_fp, roi_img)
+
+        # Convert the boxes to YOLO format.
+        labels = ""
+
+        for element in other_els:
+            el_class = element["user"]["class"]
+
+            if el_class not in class_map:
+                continue
+
+            xc, yc = element["center"][:2]
+            xc, yc = int(xc), int(yc)
+
+            # Subtract the left and top of the ROI to get the correct coordinates.
+            xc = xc - roi_left
+            yc = yc - roi_top
+
+            # Normalize by the ROI width and height.
+            xc /= roi_w
+            yc /= roi_h
+
+            w = element["width"] / roi_w
+            h = element["height"] / roi_h
+
+            labels += f"{class_map[el_class]} {xc:.4f} {yc:.4f} {w:.4f} {h:.4f}\n"
+
+        # Save the label to a text file.
+        label_fp = label_dir / f"{fn}.txt"
+
+        with open(label_fp, "w") as fh:
+            fh.write(labels.strip())
+
+        # Append all the metadata to the list.
+        roi_metadata.append(
+            [item_id, img_fp, roi_left, roi_top, roi_w, roi_h, mag, scan_mag]
+        )
+
+    return pd.DataFrame(
+        roi_metadata, columns=["item_id", "fp", "x", "y", "w", "h", "mag", "scan_mag"]
+    )

dsa_helpers-0.4.dev0/dsa_helpers/ml/object_detection/tile_image.py

@@ -0,0 +1,137 @@
+import pandas as pd
+from geopandas import GeoDataFrame
+from pathlib import Path
+import cv2 as cv
+import numpy as np
+
+from ... import imread, imwrite
+from .utils import read_yolo_label, corners_to_polygon
+
+
+def tile_image(
+    fp: str,
+    label_fp: str | None = None,
+    save_dir: str = ".",
+    tile_size: int = 1280,
+    stride: int = None,
+    boundary_thr: float = 0.2,
+    fill: tuple[int, int, int] = (114, 114, 114),
+    box_thr: float = 0.2,
+) -> pd.DataFrame:
+    """Tile an ROI image with labels.
+
+    Args:
+        fp: Image filepath, should be in an '/images/ directory'.
+        save_dir: Location to save images and labels.
+        tile_size: Size of tile, uses square tiles only.
+        stride: Stride to use when tiling, if None then it is set equal to
+            tile_size (no overlap between tiles).
+        boundary_thr: If ROI has a boundary (for rotated ROIs) then a tile must
+            have sufficient area in boundary to be included (0.0 - 1.0).
+        fill: RGB when padding image.
+        box_thr: Area threshold of box that must be in a tile.
+
+    Returns:
+        Metadata of tiles saved.
+
+    """
+    # Read the image.
+    img = imread(fp)
+    h, w = img.shape[:2]
+
+    # Get the name of the file.
+    name = Path(fp).stem
+
+    # Get the label if it exists.
+    labels = []
+
+    if label_fp is not None:
+        labels = read_yolo_label(label_fp, im_shape=(w, h), convert=True)
+
+    # Convert the labels into a GeoDataFrame.
+    label_df = []
+
+    for box in labels:
+        label = box[0]
+        x1, y1, x2, y2 = box[1:5].astype(int)
+
+        label_df.append([label, x1, y1, x2, y2, corners_to_polygon(x1, y1, x2, y2)])
+
+    label_df = GeoDataFrame(
+        label_df, columns=["label", "x1", "y1", "x2", "y2", "geometry"]
+    )
+    label_areas = label_df.area
+
+    # Depracated code for rotated ROIs.
+    roi = corners_to_polygon(0, 0, w, h)
+
+    # Make the directories to save images and label files.
+    img_dir = Path(save_dir) / "images"
+    img_dir.mkdir(parents=True, exist_ok=True)
+
+    label_dir = Path(save_dir) / "labels"
+    label_dir.mkdir(parents=True, exist_ok=True)
+
+    # Default stride is no-overlap.
+    if stride is None:
+        stride = tile_size  # default behavior - no overlap
+
+    # Pad the image to avoid getting tiles not of the right size.
+    img = cv.copyMakeBorder(
+        img, 0, tile_size, 0, tile_size, cv.BORDER_CONSTANT, value=fill
+    )
+
+    # Get the top left corner of each tile.
+    xys = list(((x, y) for x in range(0, w, stride) for y in range(0, h, stride)))
+
+    tile_df = []  # track tile data.
+
+    # Pre-calculate the number of pixels in tile that must be in ROI to include.
+    intersection_thr = tile_size**2 * boundary_thr
+
+    # loop through each tile coordinate
+    for xy in xys:
+        # Check if this tile is sufficiently in the boundary.
+        x1, y1 = xy
+        x2, y2 = x1 + tile_size, y1 + tile_size
+
+        tile_pol = corners_to_polygon(x1, y1, x2, y2)
+        intersection = roi.intersection(tile_pol).area
+
+        if intersection > intersection_thr:
+            # Get the tile image.
+            tile = img[y1:y2, x1:x2]
+
+            # Create a name for the tile image / label.
+            fn = f"{name}_x{x1}y{y1}x{x2}y{y2}"
+
+            img_fp = img_dir / f"{fn}.png"
+
+            tile_df.append([img_fp, x1, y1, x2, y2])
+
+            imwrite(str(img_fp), tile)
+
+            # Find all boxes that intersect
+            label_intersection = label_df.geometry.intersection(tile_pol).area
+
+            tile_boxes = label_df[label_intersection / label_areas > box_thr]
+
+            # save these as normalized labels, threshold the box edges.
+            if len(tile_boxes):
+                labels = ""
+
+                for _, r in tile_boxes.iterrows():
+                    # Shift coordinates to be relative to this tile.
+                    xx1 = np.clip(r.x1 - x1, 0, tile_size) / tile_size
+                    yy1 = np.clip(r.y1 - y1, 0, tile_size) / tile_size
+                    xx2 = np.clip(r.x2 - x1, 0, tile_size) / tile_size
+                    yy2 = np.clip(r.y2 - y1, 0, tile_size) / tile_size
+
+                    xc, yc = (xx1 + xx2) / 2, (yy1 + yy2) / 2
+                    bw, bh = xx2 - xx1, yy2 - yy1
+                    labels += f"{r.label} {xc:.4f} {yc:.4f} {bw:.4f} {bh:.4f}\n"
+
+                with open(str(label_dir / f"{fn}.txt"), "w") as fh:
+                    fh.write(labels.strip())
+
+    return pd.DataFrame(tile_df, columns=["fp", "x1", "y1", "x2", "y2"])

dsa_helpers-0.4.dev0/dsa_helpers/ml/object_detection/utils.py

@@ -0,0 +1,104 @@
+import numpy as np
+from shapely.geometry import Polygon
+
+
+def convert_box_type(box):
+    """Convert a box type from YOLO format (x-center, y-center, box-width, box-height) to (x1, y1, x2, y2) where point 1 is the
+    top left corner of box and point 2 is the bottom right corner
+
+    INPUT
+    -----
+    box : array
+        [N, 4], each row a point and the format being (x-center, y-center, box-width, box-height)
+
+    RETURN
+    ------
+    new_box : array
+        [N, 4] each row a point and the format x1, y1, x2, y2
+
+    """
+    # get half the box height and width
+    half_bw = box[:, 2] / 2
+    half_bh = box[:, 3] / 2
+
+    new_box = np.zeros(box.shape, dtype=box.dtype)
+    new_box[:, 0] = box[:, 0] - half_bw
+    new_box[:, 1] = box[:, 1] - half_bh
+    new_box[:, 2] = box[:, 0] + half_bw
+    new_box[:, 3] = box[:, 1] + half_bh
+
+    return new_box
+
+
+def read_yolo_label(filepath, im_shape=None, shift=None, convert=False):
+    """Read a yolo label text file. It may contain a confidence value for the labels or not, will handle both cases
+
+    INPUTS
+    ------
+    filepath : str
+        the path of the text file
+    im_shape : tuple or int (default: None)
+        image width and height corresponding to the label, if an int it is assumed both are the same. Will scale coordinates
+        to int values instead of normalized if given
+    shift : tuple or int (default: None)
+        shift value in the x and y direction, if int it is assumed to be the same in both. These values will be subtracted and applied
+        after scaling if needed
+    convert : bool (default: False)
+        If True, convert the output boxes from yolo format (label, x-center, y-center, width, height, conf) to (label, x1, y1, x2, y2, conf)
+        where point 1 is the top left corner of box and point 2 is the bottom corner of box
+
+    RETURN
+    ------
+    coords : array
+        coordinates array, [N, 4 or 5] depending if confidence was in input file
+
+    """
+    coords = []
+
+    with open(filepath, "r") as fh:
+        for line in fh.readlines():
+            if len(line):
+                coords.append([float(ln) for ln in line.strip().split(" ")])
+
+    coords = np.array(coords)
+
+    # scale coords if needed
+    if im_shape is not None:
+        if isinstance(im_shape, int):
+            w, h = im_shape, im_shape
+        else:
+            w, h = im_shape[:2]
+
+        coords[:, 1] *= w
+        coords[:, 3] *= w
+        coords[:, 2] *= h
+        coords[:, 4] *= h
+
+    # shift coords
+    if shift is not None:
+        if isinstance(shift, int):
+            x_shift, y_shift = shift, shift
+        else:
+            x_shift, y_shift = shift[:2]
+
+        coords[:, 1] -= x_shift
+        coords[:, 2] -= y_shift
+
+    if convert:
+        coords[:, 1:5] = convert_box_type(coords[:, 1:5])
+
+    return coords
+
+
+def corners_to_polygon(x1: int, y1: int, x2: int, y2: int) -> Polygon:
+    """Return a Polygon from shapely with the box coordinates given the top left and bottom right corners of a
+    rectangle (can be rotated).
+
+    Args:
+        x1, y1, x2, y2: Coordinates of the top left corner (point 1) and the bottom right corner (point 2) of a box.
+
+    Returns:
+        Shapely polygon object of the box.
+
+    """
+    return Polygon([(x1, y1), (x2, y1), (x2, y2), (x1, y2)])

{dsa_helpers-0.3.dev1 → dsa_helpers-0.4.dev0}/dsa_helpers/mongo_utils.py

@@ -8,33 +8,47 @@ from PIL import Image
 from typing import Union
 
 
-def get_mongo_database(mongo_url: str | None = None, database: str | None = None) -> pymongo.database.Database:
-    """Get a mongo database. By default the Mongo URL will be assumed from local
-    environment variables:
-        "mongodb://$MONGO_INITDB_ROOT_USERNAME:$MONGO_INITDB_ROOT_PASSWORD@mongodb:27017"
-        
-    and the database will be assumed from the environment variable "MONGODB_DB".
-    
+def get_mongo_client(
+    host: str | None = None,
+    username: str | None = None,
+    password: str | None = None,
+    port: int | None = None,
+) -> pymongo.MongoClient:
+    """Get a mongo client by providing the key parts of the URL. By default
+    when the parameters are not passed, it sets them to default values first
+    by looking at key environment variables. If the environment variables are
+    not present it sets them to default values.
+
     Args:
-        mongo_url (str): The mongo URL.
-        database (str): The database name.
-        
+        host (str, optional): The host name of the mongo server. If None it will
+            look for the environment variable "MONGO_HOST_NAME". If this is
+            missing it will default to "mongodb".
+        username (str, optional): The username to connect to the mongo server.
+            If None it will look for the environment variable
+            "MONGO_INITDB_ROOT_USERNAME". If this is missing it will default to
+            "docker".
+        password (str, optional): The password to connect to the mongo server.
+            If None it will look for the environment variable
+            "MONGO_INITDB_ROOT_PASSWORD". If this is missing it will default to
+            "docker".
+        port (int, optional): The port number of the mongo server. If None it
+            will look for the environment variable "MONGO_HOST_PORT". If this is
+            missing it will default to 27017.
+
     Returns:
-        pymongo.database.Database: The mongo database.
-    
+        pymongo.MongoClient: The mongo client.
+
     """
-    if mongo_url is None:
-        mongo_url = f"mongodb://{getenv('MONGO_INITDB_ROOT_USERNAME')}:" + \
-                    f"{getenv('MONGO_INITDB_ROOT_PASSWORD')}" + \
-                    f"@{getenv('MONGO_HOST_NAME')}:{getenv("MONGO_HOST_PORT")}"
-    
-    mc = pymongo.MongoClient(mongo_url)
-    
-    if database is None:
-        database = getenv("MONGODB_DB")
+    if username is None:
+        username = getenv("MONGO_INITDB_ROOT_USERNAME", "docker")
+    if password is None:
+        password = getenv("MONGO_INITDB_ROOT_PASSWORD", "docker")
+    if host is None:
+        host = getenv("MONGO_HOST_NAME", "mongodb")
+    if port is None:
+        port = int(getenv("MONGO_HOST_PORT", 27017))
 
-    # Return the specific database.
-    return mc[database]
+    return pymongo.MongoClient(f"mongodb://{username}:{password}@{host}:{port}")
 
 
 def chunks(lst: list, n=500):
@@ -50,20 +64,21 @@ def chunks(lst: list, n=500):
     """
     for i in range(0, len(lst), n):
         yield lst[i : i + n]
-        
-        
+
+
 def add_many_to_collection(
     mongo_collection: pymongo.collection.Collection,
-    items: dict | list, key: str = "_id"
+    items: dict | list,
+    key: str = "_id",
 ) -> dict[str | dict]:
     """Add items to a mongo collection. For this project we always add items with a unique
     user key.
-    
+
     Args:
         mongo_collection (pymongo.collection.Collection): The mongo collection to add to.
         items (dict | list): The items to add to the collection.
         key (str): The key to use to identify the items.
-        
+
     Returns:
         dict[str | dict]: The items added to the collection.
 
@@ -85,7 +100,9 @@ def add_many_to_collection(
     return items
 
 
-def get_img_from_db(mongo_db: pymongo.database.Database, img_id: str) -> Union[np.ndarray, None]:
+def get_img_from_db(
+    mongo_db: pymongo.database.Database, img_id: str
+) -> Union[np.ndarray, None]:
     """Get an image from the database by its location id.
 
     Args:
@@ -111,8 +128,8 @@ def get_img_from_db(mongo_db: pymongo.database.Database, img_id: str) -> Union[n
         src_img = np.array(Image.open(byte_io))
 
         return src_img
-    
-    
+
+
 def add_img_to_db(
     mongo_db: pymongo.database.Database,
     img: Image.Image | np.ndarray,
@@ -122,7 +139,7 @@ def add_img_to_db(
     Args:
         mongo_db (pymongo.database.Database): The mongo database.
         img (np.ndarray or PIL.Image.Image): The image.
-        
+
     Returns:
         str: The image id in the database.
 
@@ -144,4 +161,4 @@ def add_img_to_db(
     # Save the byte data to MongoDB using GridFS
     file_id = fs.put(byte_data)
 
-    return file_id
+    return file_id