finally got scene integration test working

Author: Drew Kaul

nucleus/annotation.py

@@ -289,7 +289,7 @@ def from_json(cls, payload: dict):
             dimensions=Point3D.from_json(geometry.get(DIMENSIONS_KEY, {})),
             yaw=payload.get(YAW_KEY, 0),
             reference_id=payload.get(REFERENCE_ID_KEY, None),
-            item_id=payload.get(ITEM_ID_KEY, None),
+            item_id=payload.get(DATASET_ITEM_ID_KEY, None),
             annotation_id=payload.get(ANNOTATION_ID_KEY, None),
             metadata=payload.get(METADATA_KEY, {}),
         )
@@ -310,6 +310,15 @@ def to_payload(self) -> dict:
         }
 
 
+def check_all_frame_paths_remote(frames: List[str]):
+    for frame_url in frames:
+        if is_local_path(frame_url):
+            raise ValueError(
+                f"All paths must be remote, but {frame_url} is either "
+                "local, or a remote URL type that is not supported."
+            )
+
+
 def check_all_mask_paths_remote(
     annotations: Sequence[Union[Annotation]],
 ):

nucleus/dataset.py

@@ -13,6 +13,7 @@
 from .annotation import (
     Annotation,
     check_all_mask_paths_remote,
+    check_all_frame_paths_remote,
 )
 from .constants import (
     DATASET_ITEM_IDS_KEY,
@@ -246,6 +247,31 @@ def append(
             batch_size=batch_size,
         )
 
+    def upload_scene(
+        self,
+        payload: dict,
+        update: Optional[bool] = False,
+        asynchronous: bool = False,
+    ) -> Union[dict, AsyncJob]:
+        """TODO: add docstring here"""
+        if asynchronous:
+            check_all_frame_paths_remote(payload["frames"])
+            request_id = serialize_and_write_to_presigned_url(
+                [payload], self.id, self._client
+            )
+            response = self._client.make_request(
+                payload={REQUEST_ID_KEY: request_id, UPDATE_KEY: update},
+                route=f"{self.id}/upload_scene?async=1",
+            )
+            return AsyncJob(response["job_id"], self._client)
+
+        # TODO: create client method for sync scene upload
+        response = self._client.make_request(
+            payload=payload,
+            route=f"{self.id}/upload_scene",
+        )
+        return response
+
     def iloc(self, i: int) -> dict:
         """
         Returns Dataset Item Info By Dataset Item Number.

nucleus/prediction.py

@@ -198,7 +198,7 @@ def from_json(cls, payload: dict):
             dimensions=Point3D.from_json(geometry.get(DIMENSIONS_KEY, {})),
             yaw=payload.get(YAW_KEY, 0),
             reference_id=payload.get(REFERENCE_ID_KEY, None),
-            item_id=payload.get(ITEM_ID_KEY, None),
+            item_id=payload.get(DATASET_ITEM_ID_KEY, None),
             confidence=payload.get(CONFIDENCE_KEY, None),
             annotation_id=payload.get(ANNOTATION_ID_KEY, None),
             metadata=payload.get(METADATA_KEY, {}),

nucleus/utils.py

@@ -3,6 +3,7 @@
 from collections import defaultdict
 import io
 import uuid
+import json
 from typing import IO, Dict, List, Sequence, Union
 
 import requests
@@ -120,11 +121,14 @@ def convert_export_payload(api_payload):
 
 
 def serialize_and_write(
-    upload_units: Sequence[Union[DatasetItem, Annotation]], file_pointer
+    upload_units: Sequence[Union[DatasetItem, Annotation, Dict]], file_pointer
 ):
     for unit in upload_units:
         try:
-            file_pointer.write(unit.to_json() + "\n")
+            if isinstance(unit, (DatasetItem, Annotation)):
+                file_pointer.write(unit.to_json() + "\n")
+            else:
+                file_pointer.write(json.dumps(unit) + "\n")
         except TypeError as e:
             type_name = type(unit).__name__
             message = (
@@ -151,7 +155,7 @@ def upload_to_presigned_url(presigned_url: str, file_pointer: IO):
 
 
 def serialize_and_write_to_presigned_url(
-    upload_units: Sequence[Union["DatasetItem", Annotation]],
+    upload_units: Sequence[Union[DatasetItem, Annotation, Dict]],
     dataset_id: str,
     client,
 ):

tests/helpers.py

@@ -23,9 +23,11 @@
 ]
 
 TEST_POINTCLOUD_URLS = [
-    "https://scale-us-attachments.s3.us-west-2.amazonaws.com/select/examples/kitti_example_frame.json",
+    "https://scaleapi-cust-lidar.s3.us-west-1.amazonaws.com/test-scale/frame-0.json",
 ]
 
+TEST_LIDAR_FRAMES = {"frames": TEST_POINTCLOUD_URLS}
+
 TEST_DATASET_ITEMS = [
     DatasetItem(TEST_IMG_URLS[0], "1"),
     DatasetItem(TEST_IMG_URLS[1], "2"),
@@ -93,7 +95,6 @@ def reference_id_from_url(url):
             },
             "yaw": 5 * i,
         },
-        "reference_id": reference_id_from_url(TEST_POINTCLOUD_URLS[i]),
         "annotation_id": f"[Pytest] Cuboid Annotation Annotation Id{i}",
     }
     for i in range(len(TEST_POINTCLOUD_URLS))
@@ -191,19 +192,19 @@ def assert_cuboid_annotation_matches_dict(
     assert (
         annotation_instance.annotation_id == annotation_dict["annotation_id"]
     )
-    for instance_pt, dict_pt in zip(
-        annotation_instance.position, annotation_dict["geometry"]["position"]
-    ):
-        assert instance_pt.x == dict_pt["x"]
-        assert instance_pt.y == dict_pt["y"]
-        assert instance_pt.z == dict_pt["z"]
-    for instance_pt, dict_pt in zip(
-        annotation_instance.dimensions,
-        annotation_dict["geometry"]["dimensions"],
-    ):
-        assert instance_pt.x == dict_pt["x"]
-        assert instance_pt.y == dict_pt["y"]
-        assert instance_pt.z == dict_pt["z"]
+
+    instance_pos = annotation_instance.position
+    dict_pos = annotation_dict["geometry"]["position"]
+    assert instance_pos.x == dict_pos["x"]
+    assert instance_pos.y == dict_pos["y"]
+    assert instance_pos.z == dict_pos["z"]
+
+    instance_dim = annotation_instance.dimensions
+    dict_dim = annotation_dict["geometry"]["dimensions"]
+    assert instance_dim.x == dict_dim["x"]
+    assert instance_dim.y == dict_dim["y"]
+    assert instance_dim.z == dict_dim["z"]
+
     assert annotation_instance.yaw == annotation_dict["geometry"]["yaw"]
 
 

tests/test_annotation.py

@@ -2,24 +2,19 @@
 
 from .helpers import (
     TEST_DATASET_NAME,
-    TEST_DATASET_3D_NAME,
     TEST_IMG_URLS,
-    TEST_POINTCLOUD_URLS,
     TEST_BOX_ANNOTATIONS,
     TEST_POLYGON_ANNOTATIONS,
-    TEST_CUBOID_ANNOTATIONS,
     TEST_SEGMENTATION_ANNOTATIONS,
     reference_id_from_url,
     assert_box_annotation_matches_dict,
     assert_polygon_annotation_matches_dict,
-    assert_cuboid_annotation_matches_dict,
     assert_segmentation_annotation_matches_dict,
 )
 
 from nucleus import (
     BoxAnnotation,
     PolygonAnnotation,
-    CuboidAnnotation,
     SegmentationAnnotation,
     DatasetItem,
     Segment,
@@ -66,26 +61,6 @@ def dataset(CLIENT):
     assert response == {"message": "Beginning dataset deletion..."}
 
 
-@pytest.fixture()
-def dataset_3d(CLIENT):
-    ds = CLIENT.create_dataset(TEST_DATASET_3D_NAME)
-    ds_items = []
-    for url in TEST_POINTCLOUD_URLS:
-        ds_items.append(
-            DatasetItem(
-                image_location=url,
-                reference_id=reference_id_from_url(url),
-            )
-        )
-
-    response = ds.append(ds_items)
-    assert ERROR_PAYLOAD not in response.json()
-    yield ds
-
-    response = CLIENT.delete_dataset(ds.id)
-    assert response == {"message": "Beginning dataset deletion..."}
-
-
 def test_box_gt_upload(dataset):
     annotation = BoxAnnotation(**TEST_BOX_ANNOTATIONS[0])
     response = dataset.annotate(annotations=[annotation])
@@ -120,24 +95,6 @@ def test_polygon_gt_upload(dataset):
     )
 
 
-def test_cuboid_gt_upload(dataset_3d):
-    annotation = CuboidAnnotation.from_json(TEST_CUBOID_ANNOTATIONS[0])
-    response = dataset_3d.annotate(annotations=[annotation])
-
-    assert response["dataset_id"] == dataset_3d.id
-    assert response["annotations_processed"] == 1
-    assert response["annotations_ignored"] == 0
-
-    response = dataset_3d.refloc(annotation.reference_id)["annotations"][
-        "cuboid"
-    ]
-    assert len(response) == 1
-    response_annotation = response[0]
-    assert_cuboid_annotation_matches_dict(
-        response_annotation, TEST_CUBOID_ANNOTATIONS[0]
-    )
-
-
 def test_single_semseg_gt_upload(dataset):
     annotation = SegmentationAnnotation.from_json(
         TEST_SEGMENTATION_ANNOTATIONS[0]

tests/test_scene.py

@@ -0,0 +1,47 @@
+import pytest
+
+from .helpers import (
+    TEST_DATASET_3D_NAME,
+    TEST_CUBOID_ANNOTATIONS,
+    TEST_LIDAR_FRAMES,
+    assert_cuboid_annotation_matches_dict,
+)
+
+from nucleus import (
+    CuboidAnnotation,
+)
+
+
+@pytest.fixture()
+def dataset(CLIENT):
+    ds = CLIENT.create_dataset(TEST_DATASET_3D_NAME)
+    yield ds
+
+    response = CLIENT.delete_dataset(ds.id)
+    assert response == {"message": "Beginning dataset deletion..."}
+
+
+@pytest.mark.integration
+def test_scene_upload_sync(dataset):
+    payload = TEST_LIDAR_FRAMES
+    response = dataset.upload_scene(payload)
+
+    assert response["dataset_id"] == dataset.id
+    assert response["new_items"] == 1
+    assert response["updated_items"] == 0
+    assert response["ignored_items"] == 0
+
+    TEST_CUBOID_ANNOTATIONS[0]["dataset_item_id"] = dataset.items[0].item_id
+    annotation = CuboidAnnotation.from_json(TEST_CUBOID_ANNOTATIONS[0])
+    response = dataset.annotate(annotations=[annotation])
+
+    assert response["dataset_id"] == dataset.id
+    assert response["annotations_processed"] == 1
+    assert response["annotations_ignored"] == 0
+
+    response = dataset.loc(annotation.item_id)["annotations"]["cuboid"]
+    assert len(response) == 1
+    response_annotation = response[0]
+    assert_cuboid_annotation_matches_dict(
+        response_annotation, TEST_CUBOID_ANNOTATIONS[0]
+    )