scale-nucleus 0.1.1__py3-none-any.whl → 0.1.10__py3-none-any.whl

nucleus/__init__.py

@@ -50,89 +50,83 @@ confidence      |   float   |   The optional confidence level of this annotation
 geometry        |   dict    |   Representation of the bounding box in the Box2DGeometry format.\n
 metadata        |   dict    |   An arbitrary metadata blob for the annotation.\n
 """
-__version__ = "0.1.0"
-
+import asyncio
 import json
 import logging
-import warnings
 import os
-from typing import List, Union, Dict, Callable, Any, Optional
+from typing import Any, Dict, List, Optional, Union
 
+import aiohttp
+import pkg_resources
+import requests
 import tqdm
 import tqdm.notebook as tqdm_notebook
 
-import grequests
-import requests
-from requests.adapters import HTTPAdapter
-
-# pylint: disable=E1101
-# TODO: refactor to reduce this file to under 1000 lines.
-# pylint: disable=C0302
-from requests.packages.urllib3.util.retry import Retry
-
-from .constants import REFERENCE_IDS_KEY, DATASET_ITEM_IDS_KEY
-from .dataset import Dataset
-from .dataset_item import DatasetItem
 from .annotation import (
     BoxAnnotation,
     PolygonAnnotation,
-    SegmentationAnnotation,
     Segment,
-)
-from .prediction import (
-    BoxPrediction,
-    PolygonPrediction,
-    SegmentationPrediction,
-)
-from .model_run import ModelRun
-from .slice import Slice
-from .upload_response import UploadResponse
-from .payload_constructor import (
-    construct_append_payload,
-    construct_annotation_payload,
-    construct_model_creation_payload,
-    construct_box_predictions_payload,
-    construct_segmentation_payload,
+    SegmentationAnnotation,
+    Point,
 )
 from .constants import (
-    NUCLEUS_ENDPOINT,
+    ANNOTATION_METADATA_SCHEMA_KEY,
+    ANNOTATIONS_IGNORED_KEY,
+    ANNOTATIONS_PROCESSED_KEY,
+    AUTOTAGS_KEY,
+    DATASET_ID_KEY,
+    DATASET_ITEM_IDS_KEY,
     DEFAULT_NETWORK_TIMEOUT_SEC,
-    ERRORS_KEY,
+    EMBEDDINGS_URL_KEY,
     ERROR_ITEMS,
     ERROR_PAYLOAD,
-    ITEMS_KEY,
-    ITEM_KEY,
+    ERRORS_KEY,
     IMAGE_KEY,
     IMAGE_URL_KEY,
-    DATASET_ID_KEY,
+    ITEM_METADATA_SCHEMA_KEY,
+    ITEMS_KEY,
     MODEL_RUN_ID_KEY,
-    DATASET_ITEM_ID_KEY,
-    SLICE_ID_KEY,
-    ANNOTATIONS_PROCESSED_KEY,
-    ANNOTATIONS_IGNORED_KEY,
-    PREDICTIONS_PROCESSED_KEY,
+    NAME_KEY,
+    NUCLEUS_ENDPOINT,
     PREDICTIONS_IGNORED_KEY,
+    PREDICTIONS_PROCESSED_KEY,
+    REFERENCE_IDS_KEY,
+    SLICE_ID_KEY,
     STATUS_CODE_KEY,
-    SUCCESS_STATUS_CODES,
-    DATASET_NAME_KEY,
-    DATASET_MODEL_RUNS_KEY,
-    DATASET_SLICES_KEY,
-    DATASET_LENGTH_KEY,
-    NAME_KEY,
-    ANNOTATIONS_KEY,
-    AUTOTAGS_KEY,
-    ANNOTATION_METADATA_SCHEMA_KEY,
-    ITEM_METADATA_SCHEMA_KEY,
-    FORCE_KEY,
-    EMBEDDINGS_URL_KEY,
+    UPDATE_KEY,
 )
-from .model import Model
+from .dataset import Dataset
+from .dataset_item import DatasetItem
 from .errors import (
+    DatasetItemRetrievalError,
     ModelCreationError,
     ModelRunCreationError,
-    DatasetItemRetrievalError,
     NotFoundError,
+    NucleusAPIError,
+)
+from .model import Model
+from .model_run import ModelRun
+from .payload_constructor import (
+    construct_annotation_payload,
+    construct_append_payload,
+    construct_box_predictions_payload,
+    construct_model_creation_payload,
+    construct_segmentation_payload,
 )
+from .prediction import (
+    BoxPrediction,
+    PolygonPrediction,
+    SegmentationPrediction,
+)
+from .slice import Slice
+from .upload_response import UploadResponse
+
+# pylint: disable=E1101
+# TODO: refactor to reduce this file to under 1000 lines.
+# pylint: disable=C0302
+
+
+__version__ = pkg_resources.get_distribution("scale-nucleus").version
 
 logger = logging.getLogger(__name__)
 logging.basicConfig()
@@ -146,15 +140,26 @@ class NucleusClient:
     Nucleus client.
     """
 
-    def __init__(self, api_key: str, use_notebook: bool = False):
+    def __init__(
+        self,
+        api_key: str,
+        use_notebook: bool = False,
+        endpoint: str = None,
+    ):
         self.api_key = api_key
         self.tqdm_bar = tqdm.tqdm
+        if endpoint is None:
+            self.endpoint = os.environ.get(
+                "NUCLEUS_ENDPOINT", NUCLEUS_ENDPOINT
+            )
+        else:
+            self.endpoint = endpoint
         self._use_notebook = use_notebook
         if use_notebook:
             self.tqdm_bar = tqdm_notebook.tqdm
 
     def __repr__(self):
-        return f"NucleusClient(api_key='{self.api_key}', use_notebook={self._use_notebook})"
+        return f"NucleusClient(api_key='{self.api_key}', use_notebook={self._use_notebook}, endpoint='{self.endpoint}')"
 
     def __eq__(self, other):
         if self.api_key == other.api_key:
@@ -167,7 +172,7 @@ class NucleusClient:
         Lists available models in your repo.
         :return: model_ids
         """
-        model_objects = self._make_request({}, "models/", requests.get)
+        model_objects = self.make_request({}, "models/", requests.get)
 
         return [
             Model(
@@ -185,14 +190,14 @@ class NucleusClient:
         Lists available datasets in your repo.
         :return: { datasets_ids }
         """
-        return self._make_request({}, "dataset/", requests.get)
+        return self.make_request({}, "dataset/", requests.get)
 
     def get_dataset_items(self, dataset_id) -> List[DatasetItem]:
         """
         Gets all the dataset items inside your repo as a json blob.
         :return [ DatasetItem ]
         """
-        response = self._make_request(
+        response = self.make_request(
             {}, f"dataset/{dataset_id}/datasetItems", requests.get
         )
         dataset_items = response.get("dataset_items", None)
@@ -221,13 +226,15 @@ class NucleusClient:
         """
         return Dataset(dataset_id, self)
 
-    def get_model_run(self, model_run_id: str) -> ModelRun:
+    def get_model_run(self, model_run_id: str, dataset_id: str) -> ModelRun:
         """
         Fetches a model_run for given id
         :param model_run_id: internally controlled model_run_id
+        :param dataset_id: the dataset id which may determine the prediction schema
+            for this model run if present on the dataset.
         :return: model_run
         """
-        return ModelRun(model_run_id, self)
+        return ModelRun(model_run_id, dataset_id, self)
 
     def delete_model_run(self, model_run_id: str):
         """
@@ -235,7 +242,7 @@ class NucleusClient:
         :param model_run_id: internally controlled model_run_id
         :return: model_run
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"modelRun/{model_run_id}", requests.delete
         )
 
@@ -254,7 +261,7 @@ class NucleusClient:
             payload["last_n_tasks"] = str(last_n_tasks)
         if name:
             payload["name"] = name
-        response = self._make_request(payload, "dataset/create_from_project")
+        response = self.make_request(payload, "dataset/create_from_project")
         return Dataset(response[DATASET_ID_KEY], self)
 
     def create_dataset(
@@ -271,7 +278,7 @@ class NucleusClient:
         :param annotation_metadata_schema -- optional dictionary to define annotation metadata schema
         :return: new Dataset object
         """
-        response = self._make_request(
+        response = self.make_request(
             {
                 NAME_KEY: name,
                 ANNOTATION_METADATA_SCHEMA_KEY: annotation_metadata_schema,
@@ -289,7 +296,7 @@ class NucleusClient:
         :param payload: { "name": str }
         :return: { "dataset_id": str, "name": str }
         """
-        return self._make_request({}, f"dataset/{dataset_id}", requests.delete)
+        return self.make_request({}, f"dataset/{dataset_id}", requests.delete)
 
     def delete_dataset_item(
         self, dataset_id: str, item_id: str = None, reference_id: str = None
@@ -302,11 +309,11 @@ class NucleusClient:
         :return: { "dataset_id": str, "name": str }
         """
         if item_id:
-            return self._make_request(
+            return self.make_request(
                 {}, f"dataset/{dataset_id}/{item_id}", requests.delete
             )
         else:  # Assume reference_id is provided
-            return self._make_request(
+            return self.make_request(
                 {},
                 f"dataset/{dataset_id}/refloc/{reference_id}",
                 requests.delete,
@@ -317,13 +324,13 @@ class NucleusClient:
         dataset_id: str,
         dataset_items: List[DatasetItem],
         batch_size: int = 100,
-        force: bool = False,
+        update: bool = False,
     ):
         """
         Appends images to a dataset with given dataset_id.
-        Overwrites images on collision if forced.
+        Overwrites images on collision if updated.
         :param dataset_id: id of a dataset
-        :param payload: { "items": List[DatasetItem], "force": bool }
+        :param payload: { "items": List[DatasetItem], "update": bool }
         :param local: flag if images are stored locally
         :param batch_size: size of the batch for long payload
         :return:
@@ -366,21 +373,24 @@ class NucleusClient:
         async_responses: List[Any] = []
 
         for batch in tqdm_local_batches:
-            payload = construct_append_payload(batch, force)
+            payload = construct_append_payload(batch, update)
             responses = self._process_append_requests_local(
-                dataset_id, payload, force
+                dataset_id, payload, update
             )
             async_responses.extend(responses)
 
         for batch in tqdm_remote_batches:
-            payload = construct_append_payload(batch, force)
+            payload = construct_append_payload(batch, update)
             responses = self._process_append_requests(
-                dataset_id, payload, force, batch_size, batch_size
+                dataset_id=dataset_id,
+                payload=payload,
+                update=update,
+                batch_size=batch_size,
             )
             async_responses.extend(responses)
 
         for response in async_responses:
-            agg_response.update_response(response.json())
+            agg_response.update_response(response)
 
         return agg_response
 
@@ -388,28 +398,24 @@ class NucleusClient:
         self,
         dataset_id: str,
         payload: dict,
-        update: bool,
+        update: bool,  # TODO: understand how to pass this in.
         local_batch_size: int = 10,
-        size: int = 10,
     ):
-        def error(batch_items: dict) -> UploadResponse:
-            return UploadResponse(
-                {
-                    DATASET_ID_KEY: dataset_id,
-                    ERROR_ITEMS: len(batch_items),
-                    ERROR_PAYLOAD: batch_items,
-                }
-            )
-
-        def exception_handler(request, exception):
-            logger.error(exception)
-
-        def preprocess_payload(batch):
+        def get_files(batch):
             request_payload = [
-                (ITEMS_KEY, (None, json.dumps(batch), "application/json"))
+                (
+                    ITEMS_KEY,
+                    (
+                        None,
+                        json.dumps(batch, allow_nan=False),
+                        "application/json",
+                    ),
+                )
             ]
             for item in batch:
-                image = open(item.get(IMAGE_URL_KEY), "rb")
+                image = open(  # pylint: disable=R1732
+                    item.get(IMAGE_URL_KEY), "rb"  # pylint: disable=R1732
+                )  # pylint: disable=R1732
                 img_name = os.path.basename(image.name)
                 img_type = (
                     f"image/{os.path.splitext(image.name)[1].strip('.')}"
@@ -421,27 +427,19 @@ class NucleusClient:
 
         items = payload[ITEMS_KEY]
         responses: List[Any] = []
-        request_payloads = []
+        files_per_request = []
         payload_items = []
         for i in range(0, len(items), local_batch_size):
             batch = items[i : i + local_batch_size]
-            batch_payload = preprocess_payload(batch)
-            request_payloads.append(batch_payload)
+            files_per_request.append(get_files(batch))
             payload_items.append(batch)
 
-        async_requests = [
-            self._make_grequest(
-                payload,
+        loop = asyncio.get_event_loop()
+        responses = loop.run_until_complete(
+            self.make_many_files_requests_asynchronously(
+                files_per_request,
                 f"dataset/{dataset_id}/append",
-                local=True,
             )
-            for payload in request_payloads
-        ]
-
-        async_responses = grequests.map(
-            async_requests,
-            exception_handler=exception_handler,
-            size=size,
         )
 
         def close_files(request_items):
@@ -451,69 +449,106 @@ class NucleusClient:
                     item[1][1].close()
 
         # don't forget to close all open files
-        for p in request_payloads:
+        for p in files_per_request:
             close_files(p)
 
-        # response object will be None if an error occurred
-        async_responses = [
-            response
-            if (response and response.status_code == 200)
-            else error(request_items)
-            for response, request_items in zip(async_responses, payload_items)
-        ]
-        responses.extend(async_responses)
-
         return responses
 
+    async def make_many_files_requests_asynchronously(
+        self, files_per_request, route
+    ):
+        """
+        Makes an async post request with files to a Nucleus endpoint.
+
+        :param files_per_request: A list of lists of tuples (name, (filename, file_pointer, content_type))
+           name will become the name by which the multer can build an array.
+        :param route: route for the request
+        :return: awaitable list(response)
+        """
+        async with aiohttp.ClientSession() as session:
+            tasks = [
+                asyncio.ensure_future(
+                    self._make_files_request(
+                        files=files, route=route, session=session
+                    )
+                )
+                for files in files_per_request
+            ]
+            return await asyncio.gather(*tasks)
+
+    async def _make_files_request(
+        self,
+        files,
+        route: str,
+        session: aiohttp.ClientSession,
+    ):
+        """
+        Makes an async post request with files to a Nucleus endpoint.
+
+        :param files: A list of tuples (name, (filename, file_pointer, file_type))
+        :param route: route for the request
+        :param session: Session to use for post.
+        :return: response
+        """
+        endpoint = f"{self.endpoint}/{route}"
+
+        logger.info("Posting to %s", endpoint)
+
+        form = aiohttp.FormData()
+
+        for file in files:
+            form.add_field(
+                name=file[0],
+                filename=file[1][0],
+                value=file[1][1],
+                content_type=file[1][2],
+            )
+
+        async with session.post(
+            endpoint,
+            data=form,
+            auth=aiohttp.BasicAuth(self.api_key, ""),
+            timeout=DEFAULT_NETWORK_TIMEOUT_SEC,
+        ) as response:
+            logger.info("API request has response code %s", response.status)
+
+            try:
+                data = await response.json()
+            except aiohttp.client_exceptions.ContentTypeError:
+                # In case of 404, the server returns text
+                data = await response.text()
+
+            if not response.ok:
+                self.handle_bad_response(
+                    endpoint,
+                    session.post,
+                    aiohttp_response=(response.status, response.reason, data),
+                )
+
+            return data
+
     def _process_append_requests(
         self,
         dataset_id: str,
         payload: dict,
         update: bool,
         batch_size: int = 20,
-        size: int = 10,
     ):
-        def default_error(payload: dict) -> UploadResponse:
-            return UploadResponse(
-                {
-                    DATASET_ID_KEY: dataset_id,
-                    ERROR_ITEMS: len(payload[ITEMS_KEY]),
-                    ERROR_PAYLOAD: payload[ITEMS_KEY],
-                }
-            )
-
-        def exception_handler(request, exception):
-            logger.error(exception)
-
         items = payload[ITEMS_KEY]
         payloads = [
             # batch_size images per request
-            {ITEMS_KEY: items[i : i + batch_size], FORCE_KEY: update}
+            {ITEMS_KEY: items[i : i + batch_size], UPDATE_KEY: update}
             for i in range(0, len(items), batch_size)
         ]
 
-        async_requests = [
-            self._make_grequest(
+        return [
+            self.make_request(
                 payload,
                 f"dataset/{dataset_id}/append",
-                local=False,
             )
             for payload in payloads
         ]
 
-        async_responses = grequests.map(
-            async_requests, exception_handler=exception_handler, size=size
-        )
-
-        async_responses = [
-            response
-            if (response and response.status_code == 200)
-            else default_error(payload)
-            for response, payload in zip(async_responses, payloads)
-        ]
-
-        return async_responses
-
     def annotate_dataset(
         self,
         dataset_id: str,
@@ -566,7 +601,7 @@ class NucleusClient:
         with self.tqdm_bar(total=total_batches) as pbar:
             for batch in tqdm_batches:
                 payload = construct_annotation_payload(batch, update)
-                response = self._make_request(
+                response = self.make_request(
                     payload, f"dataset/{dataset_id}/annotate"
                 )
                 pbar.update(1)
@@ -582,7 +617,7 @@ class NucleusClient:
 
             for s_batch in semseg_batches:
                 payload = construct_segmentation_payload(s_batch, update)
-                response = self._make_request(
+                response = self.make_request(
                     payload, f"dataset/{dataset_id}/annotate_segmentation"
                 )
                 pbar.update(1)
@@ -607,9 +642,7 @@ class NucleusClient:
         :param dataset_id: id of the dataset
         :return: {"ingested_tasks": int, "ignored_tasks": int, "pending_tasks": int}
         """
-        return self._make_request(
-            payload, f"dataset/{dataset_id}/ingest_tasks"
-        )
+        return self.make_request(payload, f"dataset/{dataset_id}/ingest_tasks")
 
     def add_model(
         self, name: str, reference_id: str, metadata: Optional[Dict] = None
@@ -624,7 +657,7 @@ class NucleusClient:
         :param metadata: An optional arbitrary metadata blob for the model.
         :return: { "model_id": str }
         """
-        response = self._make_request(
+        response = self.make_request(
             construct_model_creation_payload(name, reference_id, metadata),
             "models/add",
         )
@@ -659,13 +692,15 @@ class NucleusClient:
         }
         :return: new ModelRun object
         """
-        response = self._make_request(
+        response = self.make_request(
             payload, f"dataset/{dataset_id}/modelRun/create"
         )
         if response.get(STATUS_CODE_KEY, None):
             raise ModelRunCreationError(response.get("error"))
 
-        return ModelRun(response[MODEL_RUN_ID_KEY], self)
+        return ModelRun(
+            response[MODEL_RUN_ID_KEY], dataset_id=dataset_id, client=self
+        )
 
     def predict(
         self,
@@ -723,7 +758,7 @@ class NucleusClient:
                 batch,
                 update,
             )
-            response = self._make_request(
+            response = self.make_request(
                 batch_payload, f"modelRun/{model_run_id}/predict"
             )
             if STATUS_CODE_KEY in response:
@@ -738,7 +773,7 @@ class NucleusClient:
 
         for s_batch in s_batches:
             payload = construct_segmentation_payload(s_batch, update)
-            response = self._make_request(
+            response = self.make_request(
                 payload, f"modelRun/{model_run_id}/predict_segmentation"
             )
             # pbar.update(1)
@@ -783,7 +818,7 @@ class NucleusClient:
         """
         if payload is None:
             payload = {}
-        return self._make_request(payload, f"modelRun/{model_run_id}/commit")
+        return self.make_request(payload, f"modelRun/{model_run_id}/commit")
 
     def dataset_info(self, dataset_id: str):
         """
@@ -797,7 +832,7 @@ class NucleusClient:
                 'slice_ids': List[str]
             }
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"dataset/{dataset_id}/info", requests.get
         )
 
@@ -816,7 +851,7 @@ class NucleusClient:
             "metadata": Dict[str, Any],
         }
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"modelRun/{model_run_id}/info", requests.get
         )
 
@@ -826,7 +861,7 @@ class NucleusClient:
         :param reference_id: reference_id of a dataset_item
         :return:
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"dataset/{dataset_id}/refloc/{reference_id}", requests.get
         )
 
@@ -840,7 +875,7 @@ class NucleusClient:
             "annotations": List[BoxPrediction],
         }
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"modelRun/{model_run_id}/refloc/{ref_id}", requests.get
         )
 
@@ -851,7 +886,7 @@ class NucleusClient:
         :param i: absolute number of the dataset_item
         :return:
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"dataset/{dataset_id}/iloc/{i}", requests.get
         )
 
@@ -865,7 +900,7 @@ class NucleusClient:
             "annotations": List[BoxPrediction],
         }
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"modelRun/{model_run_id}/iloc/{i}", requests.get
         )
 
@@ -880,7 +915,7 @@ class NucleusClient:
             "annotations": List[Box2DAnnotation],
         }
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"dataset/{dataset_id}/loc/{dataset_item_id}", requests.get
         )
 
@@ -894,7 +929,7 @@ class NucleusClient:
             "annotations": List[BoxPrediction],
         }
         """
-        return self._make_request(
+        return self.make_request(
             {}, f"modelRun/{model_run_id}/loc/{dataset_item_id}", requests.get
         )
 
@@ -920,7 +955,7 @@ class NucleusClient:
         }
         :return: new Slice object
         """
-        response = self._make_request(
+        response = self.make_request(
             payload, f"dataset/{dataset_id}/create_slice"
         )
         return Slice(response[SLICE_ID_KEY], self)
@@ -951,7 +986,7 @@ class NucleusClient:
             "dataset_item_ids": List[str],
         }
         """
-        response = self._make_request(
+        response = self.make_request(
             {},
             f"slice/{slice_id}",
             requests_command=requests.get,
@@ -968,7 +1003,7 @@ class NucleusClient:
         :return:
         {}
         """
-        response = self._make_request(
+        response = self.make_request(
             {},
             f"slice/{slice_id}",
             requests_command=requests.delete,
@@ -1006,9 +1041,7 @@ class NucleusClient:
         if reference_ids:
             ids_to_append[REFERENCE_IDS_KEY] = reference_ids
 
-        response = self._make_request(
-            ids_to_append, f"slice/{slice_id}/append"
-        )
+        response = self.make_request(ids_to_append, f"slice/{slice_id}/append")
         return response
 
     def list_autotags(self, dataset_id: str) -> List[str]:
@@ -1017,7 +1050,7 @@ class NucleusClient:
         :param dataset_id: internally controlled dataset_id
         :return: List[str] representing autotag_ids
         """
-        response = self._make_request(
+        response = self.make_request(
             {},
             f"{dataset_id}/list_autotags",
             requests_command=requests.get,
@@ -1035,7 +1068,7 @@ class NucleusClient:
         :return:
         {}
         """
-        response = self._make_request(
+        response = self.make_request(
             {},
             f"model/{model_id}",
             requests_command=requests.delete,
@@ -1043,82 +1076,40 @@ class NucleusClient:
         return response
 
     def create_custom_index(self, dataset_id: str, embeddings_url: str):
-        return self._make_request(
+        return self.make_request(
             {EMBEDDINGS_URL_KEY: embeddings_url},
             f"indexing/{dataset_id}",
             requests_command=requests.post,
         )
 
     def check_index_status(self, job_id: str):
-        return self._make_request(
+        return self.make_request(
             {},
             f"indexing/{job_id}",
             requests_command=requests.get,
         )
 
     def delete_custom_index(self, dataset_id: str):
-        return self._make_request(
+        return self.make_request(
             {},
             f"indexing/{dataset_id}",
             requests_command=requests.delete,
         )
 
-    def _make_grequest(
-        self,
-        payload: dict,
-        route: str,
-        session=None,
-        requests_command: Callable = grequests.post,
-        local=True,
-    ):
-        """
-        makes a grequest to Nucleus endpoint
-        :param payload: file dict for multipart-formdata
-        :param route: route for the request
-        :param session: requests.session
-        :param requests_command: grequests.post, grequests.get, grequests.delete
-        :return: An async grequest object
-        """
-        adapter = HTTPAdapter(max_retries=Retry(total=3))
-        sess = requests.Session()
-        sess.mount("https://", adapter)
-        sess.mount("http://", adapter)
-
-        endpoint = f"{NUCLEUS_ENDPOINT}/{route}"
-        logger.info("Posting to %s", endpoint)
-
-        if local:
-            post = requests_command(
-                endpoint,
-                session=sess,
-                files=payload,
-                auth=(self.api_key, ""),
-                timeout=DEFAULT_NETWORK_TIMEOUT_SEC,
-            )
-        else:
-            post = requests_command(
-                endpoint,
-                session=sess,
-                json=payload,
-                headers={"Content-Type": "application/json"},
-                auth=(self.api_key, ""),
-                timeout=DEFAULT_NETWORK_TIMEOUT_SEC,
-            )
-        return post
-
-    def _make_request_raw(
+    def make_request(
         self, payload: dict, route: str, requests_command=requests.post
-    ):
+    ) -> dict:
         """
-        Makes a request to Nucleus endpoint. This method returns the raw
-        requests.Response object which is useful for unit testing.
+        Makes a request to Nucleus endpoint and logs a warning if not
+        successful.
 
         :param payload: given payload
         :param route: route for the request
         :param requests_command: requests.post, requests.get, requests.delete
-        :return: response
+        :return: response JSON
         """
-        endpoint = f"{NUCLEUS_ENDPOINT}/{route}"
+        endpoint = f"{self.endpoint}/{route}"
+
         logger.info("Posting to %s", endpoint)
 
         response = requests_command(
@@ -1130,25 +1121,18 @@ class NucleusClient:
         )
         logger.info("API request has response code %s", response.status_code)
 
-        return response
+        if not response.ok:
+            self.handle_bad_response(endpoint, requests_command, response)
 
-    def _make_request(
-        self, payload: dict, route: str, requests_command=requests.post
-    ) -> dict:
-        """
-        Makes a request to Nucleus endpoint and logs a warning if not
-        successful.
+        return response.json()
 
-        :param payload: given payload
-        :param route: route for the request
-        :param requests_command: requests.post, requests.get, requests.delete
-        :return: response JSON
-        """
-        response = self._make_request_raw(payload, route, requests_command)
-
-        if getattr(response, "status_code") not in SUCCESS_STATUS_CODES:
-            logger.warning(response)
-
-        return (
-            response.json()
-        )  # TODO: this line fails if response has code == 404
+    def handle_bad_response(
+        self,
+        endpoint,
+        requests_command,
+        requests_response=None,
+        aiohttp_response=None,
+    ):
+        raise NucleusAPIError(
+            endpoint, requests_command, requests_response, aiohttp_response
+        )