[AL-4858][AL-4860] Reduce imports and hide NDJsonConverter

whistler · web-flow · commit 5efd92b8a59e · 2023-02-14T11:42:33.000-08:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,4 +1,11 @@
 # Changelog
+# Version 3.38.0 (2023-xx-xx)
+
+### Added
+* All imports are available via `import labelbox as lb` and `import labelbox.types as lb_types`.
+
+## Changed
+* `LabelImport.create_from_objects()`, `MALPredictionImport.create_from_objects()`, `MEAPredictionImport.create_from_objects()`, `Project.upload_annotations()`, `ModelRun.add_predictions()` now support Python Types for annotations.
 
 # Version 3.37.0 (2023-02-08)
 ## Added
diff --git a/labelbox/__init__.py b/labelbox/__init__.py
@@ -20,11 +20,12 @@
 from labelbox.schema.ontology import Ontology, OntologyBuilder, Classification, Option, Tool, FeatureSchema
 from labelbox.schema.role import Role, ProjectRole
 from labelbox.schema.invite import Invite, InviteLimit
-from labelbox.schema.data_row_metadata import DataRowMetadataOntology
+from labelbox.schema.data_row_metadata import DataRowMetadataOntology, DataRowMetadataField, DataRowMetadata, DeleteDataRowMetadata
 from labelbox.schema.model_run import ModelRun, DataSplit
 from labelbox.schema.benchmark import Benchmark
 from labelbox.schema.iam_integration import IAMIntegration
 from labelbox.schema.resource_tag import ResourceTag
 from labelbox.schema.project_resource_tag import ProjectResourceTag
 from labelbox.schema.media_type import MediaType
 from labelbox.schema.slice import Slice, CatalogSlice
+from labelbox.schema.queue_mode import QueueMode
diff --git a/labelbox/data/annotation_types/__init__.py b/labelbox/data/annotation_types/__init__.py
@@ -34,3 +34,9 @@
 from .metrics import ConfusionMatrixAggregation
 from .metrics import ScalarMetricValue
 from .metrics import ConfusionMatrixMetricValue
+
+from .data.tiled_image import EPSG
+from .data.tiled_image import EPSGTransformer
+from .data.tiled_image import TiledBounds
+from .data.tiled_image import TiledImageData
+from .data.tiled_image import TileLayer
diff --git a/labelbox/data/annotation_types/collection.py b/labelbox/data/annotation_types/collection.py
@@ -298,4 +298,4 @@ def __next__(self):
         return self._process(value)
 
 
-LabelCollection = Union[LabelList, LabelGenerator]
+LabelCollection = Union[LabelList, LabelGenerator, Iterable[Label]]
diff --git a/labelbox/data/annotation_types/geometry/geometry.py b/labelbox/data/annotation_types/geometry/geometry.py
@@ -3,9 +3,10 @@
 
 import geojson
 import numpy as np
-from shapely import geometry as geom
 from pydantic import BaseModel
 
+from shapely import geometry as geom
+
 
 class Geometry(BaseModel, ABC):
     """Abstract base class for geometry objects
diff --git a/labelbox/data/annotation_types/geometry/line.py b/labelbox/data/annotation_types/geometry/line.py
@@ -4,6 +4,7 @@
 import numpy as np
 import cv2
 from pydantic import validator
+
 from shapely.geometry import LineString as SLineString
 
 from .point import Point
diff --git a/labelbox/data/annotation_types/geometry/mask.py b/labelbox/data/annotation_types/geometry/mask.py
@@ -2,9 +2,10 @@
 
 import numpy as np
 from pydantic.class_validators import validator
-from shapely.geometry import MultiPolygon, Polygon
 import cv2
 
+from shapely.geometry import MultiPolygon, Polygon
+
 from ..data import MaskData
 from .geometry import Geometry
 
diff --git a/labelbox/data/annotation_types/geometry/polygon.py b/labelbox/data/annotation_types/geometry/polygon.py
@@ -4,6 +4,7 @@
 import geojson
 import numpy as np
 from pydantic import validator
+
 from shapely.geometry import Polygon as SPolygon
 
 from .geometry import Geometry
diff --git a/labelbox/data/annotation_types/geometry/rectangle.py b/labelbox/data/annotation_types/geometry/rectangle.py
@@ -3,6 +3,7 @@
 import cv2
 import geojson
 import numpy as np
+
 from shapely.geometry import Polygon as SPolygon
 
 from .geometry import Geometry
diff --git a/labelbox/data/metrics/iou/calculation.py b/labelbox/data/metrics/iou/calculation.py
@@ -1,8 +1,8 @@
 from typing import List, Optional, Tuple, Union
 from itertools import product
 
-from shapely.geometry import Polygon
 import numpy as np
+from shapely.geometry import Polygon
 
 from ..group import get_feature_pairs, get_identifying_key, has_no_annotations, has_no_matching_annotations
 from ...annotation_types import (ObjectAnnotation, ClassificationAnnotation,
diff --git a/labelbox/schema/annotation_import.py b/labelbox/schema/annotation_import.py
@@ -3,7 +3,7 @@
 import logging
 import os
 import time
-from typing import Any, BinaryIO, Dict, List
+from typing import Any, BinaryIO, Dict, List, Union, TYPE_CHECKING, cast
 
 import backoff
 import ndjson
@@ -16,6 +16,10 @@
 from labelbox.orm.model import Field, Relationship
 from labelbox.schema.confidence_presence_checker import LabelsConfidencePresenceChecker
 from labelbox.schema.enums import AnnotationImportState
+from labelbox.schema.serialization import serialize_labels
+
+if TYPE_CHECKING:
+    from labelbox.types import Label
 
 NDJSON_MIME_TYPE = "application/x-ndjson"
 logger = logging.getLogger(__name__)
@@ -142,13 +146,15 @@ def _create_from_bytes(cls, client, variables, query_str, file_name,
         return client.execute(data=data, files=files)
 
     @classmethod
-    def _get_ndjson_from_objects(cls, objects: List[Dict[str, Any]],
+    def _get_ndjson_from_objects(cls, objects: Union[List[Dict[str, Any]],
+                                                     List["Label"]],
                                  object_name: str) -> BinaryIO:
         if not isinstance(objects, list):
             raise TypeError(
                 f"{object_name} must be in a form of list. Found {type(objects)}"
             )
 
+        objects = serialize_labels(objects)
         data_str = ndjson.dumps(objects)
         if not data_str:
             raise ValueError(f"{object_name} cannot be empty")
@@ -212,8 +218,9 @@ def create_from_file(cls, client: "labelbox.Client", model_run_id: str,
 
     @classmethod
     def create_from_objects(
-            cls, client: "labelbox.Client", model_run_id: str, name,
-            predictions: List[Dict[str, Any]]) -> "MEAPredictionImport":
+        cls, client: "labelbox.Client", model_run_id: str, name,
+        predictions: Union[List[Dict[str, Any]], List["Label"]]
+    ) -> "MEAPredictionImport":
         """
         Create an MEA prediction import job from an in memory dictionary
 
@@ -448,8 +455,9 @@ def create_from_file(cls, client: "labelbox.Client", project_id: str,
 
     @classmethod
     def create_from_objects(
-            cls, client: "labelbox.Client", project_id: str, name: str,
-            predictions: List[Dict[str, Any]]) -> "MALPredictionImport":
+        cls, client: "labelbox.Client", project_id: str, name: str,
+        predictions: Union[List[Dict[str, Any]], List["Label"]]
+    ) -> "MALPredictionImport":
         """
         Create an MAL prediction import job from an in memory dictionary
 
@@ -463,12 +471,15 @@ def create_from_objects(
         """
         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 ignored.
-            """)
+        if len(predictions) > 0 and isinstance(predictions[0], Dict):
+            predictions_dicts = cast(List[Dict[str, Any]], predictions)
+            has_confidence = LabelsConfidencePresenceChecker.check(
+                predictions_dicts)
+            if has_confidence:
+                logger.warning("""
+                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(str(data)))
 
@@ -603,9 +614,10 @@ def create_from_file(cls, client: "labelbox.Client", project_id: str,
             raise ValueError(f"File {path} is not accessible")
 
     @classmethod
-    def create_from_objects(cls, client: "labelbox.Client", project_id: str,
-                            name: str,
-                            labels: List[Dict[str, Any]]) -> "LabelImport":
+    def create_from_objects(
+            cls, client: "labelbox.Client", project_id: str, name: str,
+            labels: Union[List[Dict[str, Any]],
+                          List["Label"]]) -> "LabelImport":
         """
         Create a label import job from an in memory dictionary
 
@@ -619,12 +631,14 @@ def create_from_objects(cls, client: "labelbox.Client", project_id: str,
         """
         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.
-            Corresponding confidence score values will be ignored.
-            """)
+        if len(labels) > 0 and isinstance(labels[0], Dict):
+            label_dicts = cast(List[Dict[str, Any]], labels)
+            has_confidence = LabelsConfidencePresenceChecker.check(label_dicts)
+            if has_confidence:
+                logger.warning("""
+                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(str(data)))
 
diff --git a/labelbox/schema/bulk_import_request.py b/labelbox/schema/bulk_import_request.py
@@ -21,9 +21,11 @@
 from labelbox.orm.db_object import DbObject
 from labelbox.orm.model import Field, Relationship
 from labelbox.schema.enums import BulkImportRequestState
+from labelbox.schema.serialization import serialize_labels
 
 if TYPE_CHECKING:
     from labelbox import Project
+    from labelbox.types import Label
 
 NDJSON_MIME_TYPE = "application/x-ndjson"
 logger = logging.getLogger(__name__)
@@ -280,7 +282,8 @@ def create_from_objects(cls,
                             client,
                             project_id: str,
                             name: str,
-                            predictions: Iterable[Dict],
+                            predictions: Union[Iterable[Dict],
+                                               Iterable["Label"]],
                             validate=True) -> 'BulkImportRequest':
         """
         Creates a `BulkImportRequest` from an iterable of dictionaries.
@@ -314,11 +317,12 @@ def create_from_objects(cls,
             raise TypeError(
                 f"annotations must be in a form of Iterable. Found {type(predictions)}"
             )
+        ndjson_predictions = serialize_labels(predictions)
 
         if validate:
-            _validate_ndjson(predictions, client.get_project(project_id))
+            _validate_ndjson(ndjson_predictions, client.get_project(project_id))
 
-        data_str = ndjson.dumps(predictions)
+        data_str = ndjson.dumps(ndjson_predictions)
         if not data_str:
             raise ValueError('annotations cannot be empty')
 
diff --git a/labelbox/schema/model_run.py b/labelbox/schema/model_run.py
@@ -18,6 +18,7 @@
 
 if TYPE_CHECKING:
     from labelbox import MEAPredictionImport
+    from labelbox.types import Label
 
 logger = logging.getLogger(__name__)
 
@@ -215,7 +216,7 @@ def upsert_predictions_and_send_to_project(
     def add_predictions(
         self,
         name: str,
-        predictions: Union[str, Path, Iterable[Dict]],
+        predictions: Union[str, Path, Iterable[Dict], Iterable["Label"]],
     ) -> 'MEAPredictionImport':  # type: ignore
         """ Uploads predictions to a new Editor project.
         Args:
diff --git a/labelbox/schema/serialization.py b/labelbox/schema/serialization.py
@@ -0,0 +1,23 @@
+from typing import cast, Any, Dict, Generator, List, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from labelbox.types import Label
+
+
+def serialize_labels(
+    objects: Union[List[Dict[str, Any]],
+                   List["Label"]]) -> List[Dict[str, Any]]:
+    """
+    Checks if objects are of type Labels and serializes labels for annotation import. Serialization depends the labelbox[data] package, therefore NDJsonConverter is only loaded if using `Label` objects instead of `dict` objects.
+    """
+    if len(objects) == 0:
+        return []
+
+    is_label_type = not isinstance(objects[0], Dict)
+    if is_label_type:
+        # If a Label object exists, labelbox[data] is already installed, so no error checking is needed.
+        from labelbox.data.serialization import NDJsonConverter
+        labels = cast(List["Label"], objects)
+        return list(NDJsonConverter.serialize(labels))
+
+    return cast(List[Dict[str, Any]], objects)
diff --git a/labelbox/types.py b/labelbox/types.py
@@ -0,0 +1,6 @@
+try:
+    from labelbox.data.annotation_types import *
+except ImportError:
+    raise ImportError(
+        "There are missing dependencies for `labelbox.types`, use `pip install labelbox[data] --upgrade` to install missing dependencies."
+    )
diff --git a/tests/integration/annotation_import/conftest.py b/tests/integration/annotation_import/conftest.py
@@ -442,10 +442,11 @@ def model_run_with_model_run_data_rows(client, configured_project,
 
 class AnnotationImportTestHelpers:
 
-    @staticmethod
-    def assert_file_content(url: str, predictions):
+    @classmethod
+    def assert_file_content(cls, url: str, predictions):
         response = requests.get(url)
-        assert response.text == ndjson.dumps(predictions)
+        predictions = cls._convert_to_plain_object(predictions)
+        assert ndjson.loads(response.text) == predictions
 
     @staticmethod
     def check_running_state(req, name, url=None):
@@ -456,6 +457,12 @@ def check_running_state(req, name, url=None):
         assert req.status_file_url is None
         assert req.state == AnnotationImportState.RUNNING
 
+    @staticmethod
+    def _convert_to_plain_object(obj):
+        """Some Python objects e.g. tuples can't be compared with JSON serialized data, serialize to JSON and deserialize to get plain objects"""
+        json_str = ndjson.dumps(obj)
+        return ndjson.loads(json_str)
+
 
 @pytest.fixture
 def annotation_import_test_helpers() -> Type[AnnotationImportTestHelpers]:
diff --git a/tests/integration/annotation_import/test_bulk_import_request.py b/tests/integration/annotation_import/test_bulk_import_request.py
@@ -3,6 +3,7 @@
 import pytest
 import random
 
+from labelbox.data.serialization import NDJsonConverter
 from labelbox.exceptions import MALValidationError, UuidError
 from labelbox.schema.bulk_import_request import BulkImportRequest
 from labelbox.schema.enums import BulkImportRequestState
@@ -56,6 +57,24 @@ def test_create_from_objects(configured_project, predictions,
         bulk_import_request.input_file_url, predictions)
 
 
+def test_create_from_label_objects(configured_project, predictions,
+                                   annotation_import_test_helpers):
+    name = str(uuid.uuid4())
+
+    labels = list(NDJsonConverter.deserialize(predictions))
+    bulk_import_request = configured_project.upload_annotations(
+        name=name, annotations=labels)
+
+    assert bulk_import_request.project() == configured_project
+    assert bulk_import_request.name == name
+    assert bulk_import_request.error_file_url is None
+    assert bulk_import_request.status_file_url is None
+    assert bulk_import_request.state == BulkImportRequestState.RUNNING
+    normalized_predictions = list(NDJsonConverter.serialize(labels))
+    annotation_import_test_helpers.assert_file_content(
+        bulk_import_request.input_file_url, normalized_predictions)
+
+
 def test_create_from_local_file(tmp_path, predictions, configured_project,
                                 annotation_import_test_helpers):
     name = str(uuid.uuid4())
diff --git a/tests/integration/annotation_import/test_label_import.py b/tests/integration/annotation_import/test_label_import.py
diff --git a/tests/integration/annotation_import/test_mea_prediction_import.py b/tests/integration/annotation_import/test_mea_prediction_import.py

Original file line number	Diff line number	Diff line change
`@@ -298,4 +298,4 @@ def __next__(self):`
`298`	`298`	`return self._process(value)`
`299`	`299`
`300`	`300`
`301`		`-LabelCollection = Union[LabelList, LabelGenerator]`
	`301`	`+LabelCollection = Union[LabelList, LabelGenerator, Iterable[Label]]`