Merge pull request #811 from Labelbox/AL-4502-improved-error-handling-for-single-annotation-uploads

Al 4502 improved error handling for single annotation uploads

Author: apollonin

labelbox/schema/annotation_import.py

@@ -141,6 +141,20 @@ def _create_from_bytes(cls, client, variables, query_str, file_name,
         files = {file_name: file_data}
         return client.execute(data=data, files=files)
 
+    @classmethod
+    def _get_ndjson_from_objects(cls, objects: List[Dict[str, Any]],
+                                 object_name: str) -> BinaryIO:
+        if not isinstance(objects, list):
+            raise TypeError(
+                f"{object_name} must be in a form of list. Found {type(objects)}"
+            )
+
+        data_str = ndjson.dumps(objects)
+        if not data_str:
+            raise ValueError(f"{object_name} cannot be empty")
+
+        return data_str.encode('utf-8')
+
     def refresh(self) -> None:
         """Synchronizes values of all fields with the database.
         """
@@ -197,8 +211,9 @@ def create_from_file(cls, client: "labelbox.Client", model_run_id: str,
             raise ValueError(f"File {path} is not accessible")
 
     @classmethod
-    def create_from_objects(cls, client: "labelbox.Client", model_run_id: str,
-                            name, predictions) -> "MEAPredictionImport":
+    def create_from_objects(
+            cls, client: "labelbox.Client", model_run_id: str, name,
+            predictions: List[Dict[str, Any]]) -> "MEAPredictionImport":
         """
         Create an MEA prediction import job from an in memory dictionary
 
@@ -210,12 +225,10 @@ def create_from_objects(cls, client: "labelbox.Client", model_run_id: str,
         Returns:
             MEAPredictionImport
         """
-        data_str = ndjson.dumps(predictions)
-        if not data_str:
-            raise ValueError('annotations cannot be empty')
-        data = data_str.encode('utf-8')
+        data = cls._get_ndjson_from_objects(predictions, 'annotations')
+
         return cls._create_mea_import_from_bytes(client, model_run_id, name,
-                                                 data, len(data))
+                                                 data, len(str(data)))
 
     @classmethod
     def create_from_url(cls, client: "labelbox.Client", model_run_id: str,
@@ -448,19 +461,16 @@ def create_from_objects(
         Returns:
             MALPredictionImport
         """
-        data_str = ndjson.dumps(predictions)
-        if not data_str:
-            raise ValueError('annotations cannot be empty')
-        data = data_str.encode('utf-8')
+        data = cls._get_ndjson_from_objects(predictions, 'annotations')
 
         has_confidence = LabelsConfidencePresenceChecker.check(predictions)
         if has_confidence:
             logger.warning("""
-            Confidence scores are not supported in MAL Prediction Import. 
-            Corresponding confidence score values will be ingored.
+            Confidence scores are not supported in MAL Prediction Import.
+            Corresponding confidence score values will be ignored.
             """)
         return cls._create_mal_import_from_bytes(client, project_id, name, data,
-                                                 len(data))
+                                                 len(str(data)))
 
     @classmethod
     def create_from_url(cls, client: "labelbox.Client", project_id: str,
@@ -607,19 +617,16 @@ def create_from_objects(cls, client: "labelbox.Client", project_id: str,
         Returns:
             LabelImport
         """
-        data_str = ndjson.dumps(labels)
-        if not data_str:
-            raise ValueError('labels cannot be empty')
-        data = data_str.encode('utf-8')
+        data = cls._get_ndjson_from_objects(labels, 'labels')
 
         has_confidence = LabelsConfidencePresenceChecker.check(labels)
         if has_confidence:
             logger.warning("""
-            Confidence scores are not supported in Label Import. 
+            Confidence scores are not supported in Label Import.
             Corresponding confidence score values will be ignored.
             """)
         return cls._create_label_import_from_bytes(client, project_id, name,
-                                                   data, len(data))
+                                                   data, len(str(data)))
 
     @classmethod
     def create_from_url(cls, client: "labelbox.Client", project_id: str,

labelbox/schema/bulk_import_request.py

@@ -310,6 +310,11 @@ def create_from_objects(cls,
         Returns:
             BulkImportRequest object
         """
+        if not isinstance(predictions, list):
+            raise TypeError(
+                f"annotations must be in a form of Iterable. Found {type(predictions)}"
+            )
+
         if validate:
             _validate_ndjson(predictions, client.get_project(project_id))
 

tests/unit/test_mal_import.py

@@ -1,4 +1,5 @@
 import uuid
+import pytest
 from unittest.mock import MagicMock, patch
 
 from labelbox.schema.annotation_import import MALPredictionImport, logger
@@ -39,3 +40,36 @@ def test_should_warn_user_about_unsupported_confidence():
             warning_mock.assert_called_once()
             "Confidence scores are not supported in MAL Prediction Import" in warning_mock.call_args_list[
                 0].args[0]
+
+
+def test_invalid_labels_format():
+    """this test should confirm that annotations are required to be in a form of list"""
+    id = str(uuid.uuid4())
+
+    label = {
+        "bbox": {
+            "height": 428,
+            "left": 2089,
+            "top": 1251,
+            "width": 158
+        },
+        "classifications": [{
+            "answer": [{
+                "schemaId": "ckrb1sfl8099e0y919v260awv",
+                "confidence": 0.894
+            }],
+            "schemaId": "ckrb1sfkn099c0y910wbo0p1a"
+        }],
+        "dataRow": {
+            "id": "ckrb1sf1i1g7i0ybcdc6oc8ct"
+        },
+        "schemaId": "ckrb1sfjx099a0y914hl319ie",
+        "uuid": "d009925d-91a3-4f67-abd9-753453f5a584"
+    }
+
+    with patch.object(MALPredictionImport, '_create_mal_import_from_bytes'):
+        with pytest.raises(TypeError):
+            MALPredictionImport.create_from_objects(client=MagicMock(),
+                                                    project_id=id,
+                                                    name=id,
+                                                    predictions=label)

tests/unit/test_unit_label_import.py

@@ -1,4 +1,5 @@
 import uuid
+import pytest
 from unittest.mock import MagicMock, patch
 
 from labelbox.schema.annotation_import import LabelImport, logger
@@ -33,3 +34,28 @@ def test_should_warn_user_about_unsupported_confidence():
             warning_mock.assert_called_once()
             "Confidence scores are not supported in Label Import" in warning_mock.call_args_list[
                 0].args[0]
+
+
+def test_invalid_labels_format():
+    """this test should confirm that labels are required to be in a form of list"""
+    id = str(uuid.uuid4())
+
+    label = {
+        "uuid": "b862c586-8614-483c-b5e6-82810f70cac0",
+        "schemaId": "ckrazcueb16og0z6609jj7y3y",
+        "dataRow": {
+            "id": "ckrazctum0z8a0ybc0b0o0g0v"
+        },
+        "bbox": {
+            "top": 1352,
+            "left": 2275,
+            "height": 350,
+            "width": 139
+        }
+    }
+    with patch.object(LabelImport, '_create_label_import_from_bytes'):
+        with pytest.raises(TypeError):
+            LabelImport.create_from_objects(client=MagicMock(),
+                                            project_id=id,
+                                            name=id,
+                                            labels=label)