[PLT-0] Migrated tests to remove all pydantic logic

libs/labelbox/tests/data/annotation_types/classification/test_classification.py

@@ -4,11 +4,11 @@
                                             Dropdown, Radio, Text,
                                             ClassificationAnnotation)
 
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_classification_answer():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         ClassificationAnswer()
 
     feature_schema_id = "schema_id"
@@ -37,15 +37,15 @@ def test_classification():
                                               name="a classification")
     assert classification.dict()['value']['answer'] == answer
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         ClassificationAnnotation()
 
 
 def test_subclass():
     answer = "1234"
     feature_schema_id = "11232"
     name = "my_feature"
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         # Should have feature schema info
         classification = ClassificationAnnotation(value=Text(answer=answer))
     classification = ClassificationAnnotation(value=Text(answer=answer),
@@ -98,11 +98,11 @@ def test_radio():
     feature_schema_id = "feature_schema_id"
     name = "my_feature"
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         classification = ClassificationAnnotation(value=Radio(
             answer=answer.name))
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         classification = Radio(answer=[answer])
     classification = Radio(answer=answer,)
     assert classification.dict() == {
@@ -159,10 +159,10 @@ def test_checklist():
     feature_schema_id = "feature_schema_id"
     name = "my_feature"
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         classification = Checklist(answer=answer.name)
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         classification = Checklist(answer=answer)
 
     classification = Checklist(answer=[answer])
@@ -208,11 +208,11 @@ def test_dropdown():
     feature_schema_id = "feature_schema_id"
     name = "my_feature"
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         classification = ClassificationAnnotation(
             value=Dropdown(answer=answer.name), name="test")
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         classification = Dropdown(answer=answer)
     classification = Dropdown(answer=[answer])
     assert classification.dict() == {

libs/labelbox/tests/data/annotation_types/data/test_raster.py

@@ -6,11 +6,11 @@
 from PIL import Image
 
 from labelbox.data.annotation_types.data import ImageData
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_validate_schema():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         data = ImageData()
 
 

libs/labelbox/tests/data/annotation_types/data/test_text.py

@@ -3,11 +3,11 @@
 import pytest
 
 from labelbox.data.annotation_types import TextData
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_validate_schema():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         data = TextData()
 
 

libs/labelbox/tests/data/annotation_types/data/test_video.py

@@ -2,11 +2,11 @@
 import pytest
 
 from labelbox.data.annotation_types import VideoData
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_validate_schema():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         data = VideoData()
 
 

libs/labelbox/tests/data/annotation_types/geometry/test_line.py

@@ -2,14 +2,14 @@
 import cv2
 
 from labelbox.data.annotation_types.geometry import Point, Line
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_line():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         line = Line()
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         line = Line(points=[[0, 1], [2, 3]])
 
     points = [[0, 1], [0, 2], [2, 2]]

libs/labelbox/tests/data/annotation_types/geometry/test_mask.py

@@ -4,11 +4,11 @@
 import cv2
 
 from labelbox.data.annotation_types import Point, Rectangle, Mask, MaskData
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_mask():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         mask = Mask()
 
     mask_data = np.zeros((32, 32, 3), dtype=np.uint8)

libs/labelbox/tests/data/annotation_types/geometry/test_point.py

@@ -2,15 +2,15 @@
 import cv2
 
 from labelbox.data.annotation_types import Point
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_point():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         line = Point()
 
     with pytest.raises(TypeError):
-        line = Point([0, 1])
+        line = Point([0, 2])
 
     point = Point(x=0, y=1)
     expected = {"coordinates": [0, 1], "type": "Point"}

libs/labelbox/tests/data/annotation_types/geometry/test_polygon.py

@@ -2,17 +2,17 @@
 import cv2
 
 from labelbox.data.annotation_types import Polygon, Point
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_polygon():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         polygon = Polygon()
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         polygon = Polygon(points=[[0, 1], [2, 3]])
 
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         polygon = Polygon(points=[Point(x=0, y=1), Point(x=0, y=1)])
 
     points = [[0., 1.], [0., 2.], [2., 2.], [2., 0.]]

libs/labelbox/tests/data/annotation_types/geometry/test_rectangle.py

@@ -2,11 +2,11 @@
 import pytest
 
 from labelbox.data.annotation_types import Point, Rectangle
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_rectangle():
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         rectangle = Rectangle()
 
     rectangle = Rectangle(start=Point(x=0, y=1), end=Point(x=10, y=10))

libs/labelbox/tests/data/annotation_types/test_annotation.py

@@ -7,7 +7,7 @@
 from labelbox.data.annotation_types.geometry.rectangle import Rectangle
 from labelbox.data.annotation_types.video import VideoClassificationAnnotation
 from labelbox.exceptions import ConfidenceNotSupportedException
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_annotation():
@@ -35,7 +35,7 @@ def test_annotation():
     )
 
     # Invalid subclass
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         ObjectAnnotation(
             value=line,
             name=name,
@@ -56,11 +56,11 @@ def test_video_annotations():
     line = Line(points=[Point(x=1, y=2), Point(x=2, y=2)])
 
     # Wrong type
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         VideoClassificationAnnotation(value=line, name=name, frame=1)
 
     # Missing frames
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         VideoClassificationAnnotation(value=line, name=name)
 
     VideoObjectAnnotation(value=line, name=name, keyframe=True, frame=2)

libs/labelbox/tests/data/annotation_types/test_label.py

@@ -1,4 +1,4 @@
-from labelbox.pydantic_compat import ValidationError
+from pydantic import ValidationError
 import numpy as np
 
 import labelbox.types as lb_types

libs/labelbox/tests/data/annotation_types/test_metrics.py

@@ -4,7 +4,7 @@
 from labelbox.data.annotation_types.metrics import ConfusionMatrixMetric, ScalarMetric
 from labelbox.data.annotation_types import ScalarMetric, Label, ImageData
 from labelbox.data.annotation_types.metrics.scalar import RESERVED_METRIC_NAMES
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 def test_legacy_scalar_metric():
@@ -156,38 +156,38 @@ def test_custom_confusison_matrix_metric(feature_name, subclass_name,
 
 def test_name_exists():
     # Name is only required for ConfusionMatrixMetric for now.
-    with pytest.raises(pydantic_compat.ValidationError) as exc_info:
+    with pytest.raises(ValidationError) as exc_info:
         metric = ConfusionMatrixMetric(value=[0, 1, 2, 3])
     assert "field required (type=value_error.missing)" in str(exc_info.value)
 
 
 def test_invalid_aggregations():
-    with pytest.raises(pydantic_compat.ValidationError) as exc_info:
+    with pytest.raises(ValidationError) as exc_info:
         metric = ScalarMetric(
             metric_name="invalid aggregation",
             value=0.1,
             aggregation=ConfusionMatrixAggregation.CONFUSION_MATRIX)
     assert "value is not a valid enumeration member" in str(exc_info.value)
-    with pytest.raises(pydantic_compat.ValidationError) as exc_info:
+    with pytest.raises(ValidationError) as exc_info:
         metric = ConfusionMatrixMetric(metric_name="invalid aggregation",
                                        value=[0, 1, 2, 3],
                                        aggregation=ScalarMetricAggregation.SUM)
     assert "value is not a valid enumeration member" in str(exc_info.value)
 
 
 def test_invalid_number_of_confidence_scores():
-    with pytest.raises(pydantic_compat.ValidationError) as exc_info:
+    with pytest.raises(ValidationError) as exc_info:
         metric = ScalarMetric(metric_name="too few scores", value={0.1: 0.1})
     assert "Number of confidence scores must be greater" in str(exc_info.value)
-    with pytest.raises(pydantic_compat.ValidationError) as exc_info:
+    with pytest.raises(ValidationError) as exc_info:
         metric = ConfusionMatrixMetric(metric_name="too few scores",
                                        value={0.1: [0, 1, 2, 3]})
     assert "Number of confidence scores must be greater" in str(exc_info.value)
-    with pytest.raises(pydantic_compat.ValidationError) as exc_info:
+    with pytest.raises(ValidationError) as exc_info:
         metric = ScalarMetric(metric_name="too many scores",
                               value={i / 20.: 0.1 for i in range(20)})
     assert "Number of confidence scores must be greater" in str(exc_info.value)
-    with pytest.raises(pydantic_compat.ValidationError) as exc_info:
+    with pytest.raises(ValidationError) as exc_info:
         metric = ConfusionMatrixMetric(
             metric_name="too many scores",
             value={i / 20.: [0, 1, 2, 3] for i in range(20)})
@@ -196,6 +196,6 @@ def test_invalid_number_of_confidence_scores():
 
 @pytest.mark.parametrize("metric_name", RESERVED_METRIC_NAMES)
 def test_reserved_names(metric_name: str):
-    with pytest.raises(pydantic_compat.ValidationError) as exc_info:
+    with pytest.raises(ValidationError) as exc_info:
         ScalarMetric(metric_name=metric_name, value=0.5)
     assert 'is a reserved metric name' in exc_info.value.errors()[0]['msg']

libs/labelbox/tests/data/annotation_types/test_tiled_image.py

@@ -7,7 +7,7 @@
                                                              TileLayer,
                                                              TiledImageData,
                                                              EPSGTransformer)
-from labelbox import pydantic_compat
+from pydantic import ValidationError
 
 
 @pytest.mark.parametrize("epsg", list(EPSG))
@@ -28,7 +28,7 @@ def test_tiled_bounds(epsg):
 @pytest.mark.parametrize("epsg", list(EPSG))
 def test_tiled_bounds_same(epsg):
     single_bound = Point(x=0, y=0)
-    with pytest.raises(pydantic_compat.ValidationError):
+    with pytest.raises(ValidationError):
         tiled_bounds = TiledBounds(epsg=epsg,
                                    bounds=[single_bound, single_bound])