Merge pull request #451 from superannotateai/assests_provider

Assests provider

Author: VaghinakDev

pytest.ini

@@ -2,4 +2,4 @@
 minversion = 3.7
 log_cli=true
 python_files = test_*.py
-addopts = -n auto --dist=loadscope
+;addopts = -n auto --dist=loadscope

requirements.txt

@@ -20,3 +20,4 @@ setuptools~=57.4.0
 aiohttp==3.8.1
 email-validator>=1.0.3
 nest-asyncio==1.5.4
+jsonschema==3.2.0

src/superannotate/lib/app/annotation_helpers.py

@@ -86,6 +86,7 @@ def add_annotation_comment_to_json(
         "y": comment_coords[1],
         "correspondence": [{"text": comment_text, "email": comment_author}],
         "resolved": resolved,
+        "creationType": "Preannotation",  # noqa
         "createdBy": user_action,
         "updatedBy": user_action,
     }
@@ -132,7 +133,6 @@ def add_annotation_bbox_to_json(
         "type": "bbox",
         "points": {"x1": bbox[0], "y1": bbox[1], "x2": bbox[2], "y2": bbox[3]},
         "className": annotation_class_name,
-        "error": error,
         "groupId": 0,
         "pointLabels": {},
         "locked": False,
@@ -141,7 +141,8 @@ def add_annotation_bbox_to_json(
         if annotation_class_attributes is None
         else annotation_class_attributes,
     }
-
+    if error is not None:
+        annotation["error"] = error
     annotation = _add_created_updated(annotation)
     annotation_json["instances"].append(annotation)
 
@@ -175,13 +176,11 @@ def add_annotation_point_to_json(
         raise AppException("Point should be 2 element float list.")
 
     annotation_json, path = _preprocess_annotation_json(annotation_json, image_name)
-
     annotation = {
         "type": "point",
         "x": point[0],
         "y": point[1],
         "className": annotation_class_name,
-        "error": error,
         "groupId": 0,
         "pointLabels": {},
         "locked": False,
@@ -190,6 +189,8 @@ def add_annotation_point_to_json(
         if annotation_class_attributes is None
         else annotation_class_attributes,
     }
+    if error is not None:
+        annotation["error"] = error
 
     annotation = _add_created_updated(annotation)
     annotation_json["instances"].append(annotation)

src/superannotate/lib/app/helpers.py

@@ -1,3 +1,4 @@
+import os
 import uuid
 from pathlib import Path
 from typing import List
@@ -128,3 +129,21 @@ def get_name_url_duplicated_from_csv(csv_path):
         else:
             duplicate_images.append(temp)
     return images_to_upload, duplicate_images
+
+
+def get_tabulation() -> int:
+    try:
+        return int(os.get_terminal_size().columns / 2)
+    except OSError:
+        return 48
+
+
+def wrap_error(errors_list: List[Tuple[str, str]]) -> str:
+    tabulation = get_tabulation()
+    msgs = []
+    for key, value in errors_list:
+        _tabulation = tabulation - len(key)
+        if not key:
+            key, value, _tabulation = value, "", 0
+        msgs.append("{}{}{}".format(key, " " * _tabulation, value))
+    return "\n".join(msgs)

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

@@ -20,6 +20,7 @@
 from lib.app.helpers import extract_project_folder
 from lib.app.helpers import get_annotation_paths
 from lib.app.helpers import get_name_url_duplicated_from_csv
+from lib.app.helpers import wrap_error as wrap_validation_errors
 from lib.app.interface.base_interface import BaseInterfaceFacade
 from lib.app.interface.base_interface import TrackableMeta
 from lib.app.interface.types import AnnotationStatuses
@@ -42,15 +43,15 @@
 from lib.core import LIMITED_FUNCTIONS
 from lib.core.entities import AttachmentEntity
 from lib.core.entities import SettingEntity
+from lib.core.entities.classes import AnnotationClassEntity
+from lib.core.entities.classes import AttributeGroup
 from lib.core.entities.integrations import IntegrationEntity
-from lib.core.entities.project_entities import AnnotationClassEntity
 from lib.core.enums import ImageQuality
 from lib.core.exceptions import AppException
-from lib.core.types import AttributeGroup
 from lib.core.types import MLModel
 from lib.core.types import PriorityScore
 from lib.core.types import Project
-from lib.infrastructure.controller import Controller
+from lib.infrastructure.validators import wrap_error
 from pydantic import conlist
 from pydantic import parse_obj_as
 from pydantic import StrictBool
@@ -579,8 +580,7 @@ def search_annotation_classes(
         """
         project_name, folder_name = extract_project_folder(project)
         classes = self.controller.search_annotation_classes(project_name, name_contains)
-        classes = [BaseSerializer(attribute).serialize() for attribute in classes.data]
-        return classes
+        return [i.dict(fill_enum_values=True) for i in classes.data]
 
     def set_project_default_image_quality_in_editor(
         self,
@@ -1140,31 +1140,94 @@ def create_annotation_class(
 
         :param project: project name
         :type project: str
+
         :param name: name for the class
         :type name: str
-        :param color: RGB hex color value, e.g., "#FFFFAA"
+
+        :param color: RGB hex color value, e.g., "#F9E0FA"
         :type color: str
-        :param attribute_groups: example:
-         [ { "name": "tall", "is_multiselect": 0, "attributes": [ { "name": "yes" }, { "name": "no" } ] },
-         { "name": "age", "is_multiselect": 0, "attributes": [ { "name": "young" }, { "name": "old" } ] } ]
+
+        :param attribute_groups:  list of attribute group dicts.
+                                  The values for the "group_type" key are  "radio"|"checklist"|"text"|"numeric".
+                                  Mandatory keys for each attribute group are
+                                      -  "name"
         :type attribute_groups: list of dicts
-        :param class_type: class type
+
+        :param class_type: class type. Should be either "object" or "tag"
         :type class_type: str
 
         :return: new class metadata
         :rtype: dict
+
+        Request Example:
+        ::
+            attributes_list = [
+               {
+                   "group_type": "radio",
+                   "name": "Vehicle",
+                   "attributes": [
+                       {
+                           "name": "Car"
+                       },
+                       {
+                           "name": "Track"
+                       },
+                       {
+                           "name": "Bus"
+                       }
+                   ],
+                   "default_value": "Car"
+               },
+               {
+                   "group_type": "checklist",
+                   "name": "Color",
+                   "attributes": [
+                       {
+                           "name": "Yellow"
+                       },
+                       {
+                           "name": "Black"
+                       },
+                       {
+                           "name": "White"
+                       }
+                   ],
+                   "default_value": ["Yellow", "White"]
+               },
+               {
+                   "group_type": "text",
+                   "name": "Timestamp"
+               },
+               {
+                   "group_type": "numeric",
+                   "name": "Description"
+               }
+            ]
+            client.create_annotation_class(
+               project="Image Project",
+               name="Example Class",
+               color="#F9E0FA",
+               attribute_groups=attributes_list
+            )
+
         """
         if isinstance(project, Project):
             project = project.dict()
         attribute_groups = (
             list(map(lambda x: x.dict(), attribute_groups)) if attribute_groups else []
         )
+        try:
+            annotation_class = AnnotationClassEntity(
+                name=name,
+                color=color,  # noqa
+                attribute_groups=attribute_groups,
+                type=class_type,  # noqa
+            )
+        except ValidationError as e:
+            raise AppException(wrap_error(e))
+
         response = self.controller.create_annotation_class(
-            project_name=project,
-            name=name,
-            color=color,
-            attribute_groups=attribute_groups,
-            class_type=class_type,
+            project_name=project, annotation_class=annotation_class
         )
         if response.errors:
             raise AppException(response.errors)
@@ -1237,9 +1300,8 @@ def create_annotation_classes_from_classes_json(
             classes_json = json.load(data)
         try:
             annotation_classes = parse_obj_as(List[AnnotationClassEntity], classes_json)
-        except ValidationError:
+        except ValidationError as _:
             raise AppException("Couldn't validate annotation classes.")
-        logger.info(f"Creating annotation classes in project {project}.")
         response = self.controller.create_annotation_classes(
             project_name=project,
             annotation_classes=annotation_classes,
@@ -1830,13 +1892,14 @@ def add_annotation_point_to_image(
             annotations,
             point,
             annotation_class_name,
-            image_name,
             annotation_class_attributes,
             error,
         )
-        self.controller.upload_image_annotations(
+        response = self.controller.upload_image_annotations(
             project_name, folder_name, image_name, annotations
         )
+        if response.errors:
+            raise AppException(response.errors)
 
     def add_annotation_comment_to_image(
         self,
@@ -2103,7 +2166,9 @@ def delete_annotations(
             raise AppException(response.errors)
 
     def validate_annotations(
-        self, project_type: ProjectTypes, annotations_json: Union[NotEmptyStr, Path]
+        self,
+        project_type: ProjectTypes,
+        annotations_json: Union[NotEmptyStr, Path, dict],
     ):
         """Validates given annotation JSON.
 
@@ -2116,16 +2181,18 @@ def validate_annotations(
         :return: The success of the validation
         :rtype: bool
         """
-        with open(annotations_json) as file:
-            annotation_data = json.loads(file.read())
-            response = Controller.validate_annotations(project_type, annotation_data)
-            if response.errors:
-                raise AppException(response.errors)
-            is_valid, _ = response.data
-            if is_valid:
-                return True
-            print(response.report)
-            return False
+        if isinstance(annotations_json, dict):
+            annotation_data = annotations_json
+        else:
+            annotation_data = json.load(open(annotations_json))
+        response = self.controller.validate_annotations(project_type, annotation_data)
+        if response.errors:
+            raise AppException(response.errors)
+        report = response.data
+        if not report:
+            return True
+        print(wrap_validation_errors(report))
+        return False
 
     def add_contributors_to_project(
         self,

src/superannotate/lib/app/serializers.py

@@ -48,7 +48,10 @@ def _serialize(
         by_alias: bool = False,
         flat: bool = False,
         exclude: Set[str] = None,
+        **kwargs
     ):
+        if not entity:
+            return None
         if isinstance(entity, dict):
             return entity
         if isinstance(entity, BaseModel):
@@ -57,13 +60,15 @@ def _serialize(
                 if len(fields) == 1:
                     if flat:
                         return entity.dict(
-                            include=fields, by_alias=by_alias, exclude=exclude
+                            include=fields, by_alias=by_alias, exclude=exclude, **kwargs
                         )[next(iter(fields))]
                     return entity.dict(
-                        include=fields, by_alias=by_alias, exclude=exclude
+                        include=fields, by_alias=by_alias, exclude=exclude, **kwargs
                     )
-                return entity.dict(include=fields, by_alias=by_alias, exclude=exclude)
-            return entity.dict(by_alias=by_alias, exclude=exclude)
+                return entity.dict(
+                    include=fields, by_alias=by_alias, exclude=exclude, **kwargs
+                )
+            return entity.dict(by_alias=by_alias, exclude=exclude, **kwargs)
         return entity.to_dict()
 
     @classmethod
@@ -74,12 +79,13 @@ def serialize_iterable(
         by_alias: bool = False,
         flat: bool = False,
         exclude: Set = None,
+        **kwargs
     ) -> List[Any]:
         serialized_data = []
         for i in data:
             serialized_data.append(
                 cls._fill_enum_values(
-                    cls._serialize(i, fields, by_alias, flat, exclude=exclude)
+                    cls._serialize(i, fields, by_alias, flat, exclude=exclude, **kwargs)
                 )
             )
         return serialized_data
@@ -150,3 +156,19 @@ def serialize(
         if data["attribute"] == "ImageQuality":
             data["value"] = constance.ImageQuality.get_name(data["value"])
         return data
+
+
+class EntitySerializer:
+    @classmethod
+    def serialize(
+        cls, data: Union[BaseModel, List[BaseModel]], **kwargs
+    ) -> Union[List[dict], dict]:
+        if isinstance(data, (list, set)):
+            for idx, item in enumerate(data):
+                data[idx] = cls.serialize(item, **kwargs)
+        for key, nested_model in data:
+            if isinstance(nested_model, BaseModel) and getattr(
+                nested_model, "fill_enum_values", False
+            ):
+                setattr(data, key, cls.serialize(nested_model, **kwargs))
+        return data.dict(**kwargs)