Merge pull request #298 from superannotateai/nested_data_validation

Added nested models validation

Author: VaghinakDev

src/superannotate/lib/app/interface/sdk_interface.py

@@ -3642,8 +3642,8 @@ def validate_annotations(
     Validates given annotation JSON.
         :param project_type: project_type (str) – the project type Vector, Pixel, Video or Document
         :type project_type: str
-        :param annotation_json: path to annotation JSON
-        :type annotation_json: Path-like (str or Path)
+        :param annotations_json: path to annotation JSON
+        :type annotations_json: Path-like (str or Path)
 
         :return: The success of the validation
         :rtype: bool

src/superannotate/lib/core/entities/document.py

@@ -3,9 +3,9 @@
 
 from lib.core.entities.utils import Attribute
 from lib.core.entities.utils import BaseInstance
+from lib.core.entities.utils import BaseModel
 from lib.core.entities.utils import MetadataBase
 from lib.core.entities.utils import Tag
-from pydantic import BaseModel
 from pydantic import Field
 
 

src/superannotate/lib/core/entities/pixel.py

@@ -2,10 +2,10 @@
 from typing import Optional
 
 from lib.core.entities.utils import BaseImageInstance
+from lib.core.entities.utils import BaseModel
 from lib.core.entities.utils import MetadataBase
 from lib.core.entities.utils import PixelColor
 from lib.core.entities.utils import Tag
-from pydantic import BaseModel
 from pydantic import Field
 
 

src/superannotate/lib/core/entities/utils.py

@@ -26,7 +26,7 @@ class Config:
             "type_error.string": "str type expected",
             "value_error.missing": "field required",
         }
-        
+
 
 class StringDate(datetime):
     @classmethod
@@ -38,7 +38,7 @@ def __get_validators__(cls):
     def validate(cls, v: datetime):
         return f'{v.replace(tzinfo=None).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3]}Z'
 
-      
+
 class VectorAnnotationTypeEnum(str, Enum):
     BBOX = "bbox"
     ELLIPSE = "ellipse"
@@ -129,8 +129,7 @@ class LastUserAction(BaseModel):
 
 
 class BaseInstance(TrackableModel, TimedBaseModel):
-    # TODO check id: Optional[str]
-    class_id: int = Field(alias="classId")
+    class_id: Optional[str] = Field(None, alias="classId")
     class_name: Optional[str] = Field(None, alias="className")
 
 

src/superannotate/lib/core/entities/vector.py

@@ -3,13 +3,13 @@
 from typing import Union
 
 from lib.core.entities.utils import AttributeGroup
+from lib.core.entities.utils import BaseModel
 from lib.core.entities.utils import BaseVectorInstance
 from lib.core.entities.utils import BboxPoints
 from lib.core.entities.utils import Comment
 from lib.core.entities.utils import Metadata
 from lib.core.entities.utils import Tag
 from lib.core.entities.utils import VectorAnnotationTypeEnum
-from pydantic import BaseModel
 from pydantic import conlist
 from pydantic import Field
 from pydantic import StrictStr
@@ -114,23 +114,29 @@ class Cuboid(BaseVectorInstance):
 }
 
 
+class AnnotationInstance(BaseModel):
+    __root__: Union[Template, Cuboid, Point, PolyLine, Polygon, Bbox, Ellipse, RotatedBox]
+
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.return_action
+
+    @classmethod
+    def return_action(cls, values):
+        try:
+            instance_type = values["type"]
+        except KeyError:
+            raise ValueError(
+                f"meta.type required"
+            )
+        try:
+            return ANNOTATION_TYPES[instance_type](**values)
+        except KeyError:
+            raise ValueError(f"invalid type, valid types is {', '.join(ANNOTATION_TYPES.keys())}")
+
+
 class VectorAnnotation(BaseModel):
     metadata: Metadata
     comments: Optional[List[Comment]] = Field(list())
     tags: Optional[List[Tag]] = Field(list())
-    instances: Optional[
-        List[
-            Union[Template, Cuboid, Point, PolyLine, Polygon, Bbox, Ellipse, RotatedBox]
-        ]
-    ] = Field(list())
-
-    @validator("instances", pre=True, each_item=True)
-    def check_instances(cls, instance):
-        # todo add type checking
-        annotation_type = instance.get("type")
-        result = validate_model(ANNOTATION_TYPES[annotation_type], instance)
-        if result[2]:
-            raise ValidationError(
-                result[2].raw_errors, model=ANNOTATION_TYPES[annotation_type]
-            )
-        return instance
+    instances: Optional[List[AnnotationInstance]] = Field(list())

src/superannotate/lib/core/entities/video_export.py

@@ -7,14 +7,15 @@
 from lib.core.entities.utils import AnnotationStatusEnum
 from lib.core.entities.utils import Attribute
 from lib.core.entities.utils import BaseInstance
+from lib.core.entities.utils import BaseModel
 from lib.core.entities.utils import BboxPoints
 from lib.core.entities.utils import MetadataBase
 from lib.core.entities.utils import NotEmptyStr
 from lib.core.entities.utils import PointLabels
 from lib.core.entities.utils import Tag
-from pydantic import BaseModel
 from pydantic import conlist
 from pydantic import Field
+from pydantic import validator
 
 
 class VideoType(str, Enum):
@@ -24,15 +25,15 @@ class VideoType(str, Enum):
 
 class MetaData(MetadataBase):
     name: NotEmptyStr
-    url: str
+    url: Optional[str]
     status: Optional[AnnotationStatusEnum]
     duration: Optional[int]
     error: Optional[bool]
 
 
 class BaseTimeStamp(BaseModel):
     timestamp: int
-    attributes: List[Attribute]  # TODO check is it required
+    attributes: List[Attribute]
 
 
 class BboxTimeStamp(BaseTimeStamp):
@@ -55,11 +56,11 @@ class Config:
 
 
 class BBoxInstanceMetadata(InstanceMetadata):
-    type: str = Field(VideoType.BBOX, const=True)
+    type: VideoType = Field(VideoType.BBOX.value, const=True)
 
 
 class EventInstanceMetadata(InstanceMetadata):
-    type: str = Field(VideoType.EVENT, const=True)
+    type: VideoType = Field(VideoType.EVENT.value, const=True)
 
 
 class BaseVideoInstance(BaseModel):
@@ -93,10 +94,34 @@ class EventInstance(BaseModel):
     parameters: conlist(EventParameter, min_items=1)
 
 
-ANNOTATION_TYPES = {VideoType.BBOX: BboxInstance, VideoType.EVENT: EventInstance}
+INSTANCES = {
+    VideoType.BBOX.value: BboxInstance,
+    VideoType.EVENT.value: EventInstance
+}
+
+
+class VideoInstance(BaseModel):
+    __root__: Union[BboxInstance, EventInstance]
+
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.return_action
+
+    @classmethod
+    def return_action(cls, values):
+        try:
+            instance_type = values["meta"]["type"]
+        except KeyError:
+            raise ValueError(
+                f"meta.type required"
+            )
+        try:
+            return INSTANCES[instance_type](**values)
+        except KeyError:
+            raise ValueError(f"invalid type, valid types is {', '.join(INSTANCES.keys())}")
 
 
 class VideoAnnotation(BaseModel):
     metadata: MetaData
-    instances: Optional[List[Union[EventInstance, BboxInstance]]] = Field(list())
+    instances: Optional[List[VideoInstance]] = Field(list())
     tags: Optional[List[Tag]] = Field(list())

tests/integration/test_interface.py

@@ -251,6 +251,3 @@ def test_create_folder_with_special_character(self):
                 'Folder __abc (1) created in project Interface Pixel test',
                 logs.output[4]
             )
-
-    def test_(self):
-        sa.upload_annotations_from_folder_to_project("PROJECT_2", "/Users/vaghinak.basentsyan/www/for_fun/data")

tests/unit/test_validators.py

@@ -86,3 +86,73 @@ def test_validate_annotation_without_metadata(self):
             with catch_prints() as out:
                 sa.validate_annotations("Vector", os.path.join(self.vector_folder_path, f"{tmpdir_name}/vector.json"))
                 self.assertIn("metadatafieldrequired", out.getvalue().strip().replace(" ", ""))
+
+
+class TestTypeHandling(TestCase):
+    ANNOTATION = """
+    {
+        "metadata": {
+        "name": "example_image_1.jpg",
+        "width": 1024,
+        "height": 683,
+        "status": "Completed",
+        "pinned": false,
+        "isPredicted": null,
+        "projectId": null,
+        "annotatorEmail": null,
+        "qaEmail": null
+        },
+        "instances": [
+        {
+          "type": "invalid_type",
+          "classId": 72274,
+          "probability": 100,
+          "points": {
+            
+            "x2": 465.23,
+            "y1": 341.5,
+            "y2": 357.09
+          },
+          "groupId": 0,
+          "pointLabels": {},
+          "locked": false,
+          "visible": false,
+          "attributes": [
+            {
+              "id": 117845,
+              "groupId": 28230,
+              "name": "2",
+              "groupName": "Num doors"
+            }
+          ],
+          "trackingId": "aaa97f80c9e54a5f2dc2e920fc92e5033d9af45b",
+          "error": null,
+          "createdAt": null,
+          "createdBy": null,
+          "creationType": null,
+          "updatedAt": null,
+          "updatedBy": null,
+          "className": "Personal vehicle"
+        }
+        ]
+        }
+    """
+
+    TEST_VECTOR_FOLDER_PATH = "data_set/sample_project_vector"
+    VECTOR_JSON = "example_image_1.jpg___objects.json"
+
+    @property
+    def vector_folder_path(self):
+        return os.path.join(dirname(dirname(__file__)), self.TEST_VECTOR_FOLDER_PATH)
+
+    def test_validate_annotation_with_wrong_bbox(self):
+        with tempfile.TemporaryDirectory() as tmpdir_name:
+            with open(f"{tmpdir_name}/vector.json", "w") as vector_json:
+                vector_json.write(self.ANNOTATION)
+            with catch_prints() as out:
+                sa.validate_annotations("Vector", os.path.join(self.vector_folder_path, f"{tmpdir_name}/vector.json"))
+                self.assertEqual(
+                    "instances[0]invalidtype,validtypesisbbox,"
+                    "template,cuboid,polygon,point,polyline,ellipse,rbbox",
+                    out.getvalue().strip().replace(" ", "")
+                )