Merge branch 'friday' into 1855_annotations

Author: VaghinakDev

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

@@ -1400,7 +1400,8 @@ def create_annotation_class(
         :type color: str
 
         :param attribute_groups:  list of attribute group dicts.
-            The values for the "group_type" key are  "radio"|"checklist"|"text"|"numeric".
+            The values for the "group_type" key are "radio"|"checklist"|"text"|"numeric"|"ocr".
+            "ocr "group_type" key is only available for Vector projects.
             Mandatory keys for each attribute group are
 
               -  "name"

src/superannotate/lib/core/usecases/__init__.py

@@ -1,3 +1,4 @@
+import nest_asyncio
 from lib.core.usecases.annotations import *  # noqa: F403 F401
 from lib.core.usecases.classes import *  # noqa: F403 F401
 from lib.core.usecases.custom_fields import *  # noqa: F403 F401
@@ -7,3 +8,5 @@
 from lib.core.usecases.items import *  # noqa: F403 F401
 from lib.core.usecases.models import *  # noqa: F403 F401
 from lib.core.usecases.projects import *  # noqa: F403 F401
+
+nest_asyncio.apply()

src/superannotate/lib/core/usecases/annotations.py

@@ -26,7 +26,6 @@
 import boto3
 import jsonschema.validators
 import lib.core as constants
-import nest_asyncio
 from jsonschema import Draft7Validator
 from jsonschema import ValidationError
 from lib.core.conditions import Condition
@@ -391,7 +390,6 @@ def execute(self):
                 len(items_to_upload), description="Uploading Annotations"
             )
             try:
-                nest_asyncio.apply()
                 asyncio.run(self.run_workers(items_to_upload))
             except Exception:
                 logger.debug(traceback.format_exc())
@@ -737,7 +735,6 @@ def execute(self):
             except KeyError:
                 missing_annotations.append(name)
         try:
-            nest_asyncio.apply()
             asyncio.run(self.run_workers(items_to_upload))
         except Exception as e:
             logger.debug(e)
@@ -935,7 +932,6 @@ def execute(self):
                 json.dump(annotation_json, annotation_file)
                 size = annotation_file.tell()
                 annotation_file.seek(0)
-                nest_asyncio.apply()
                 if size > BIG_FILE_THRESHOLD:
                     uploaded = asyncio.run(
                         self._service_provider.annotations.upload_big_annotation(
@@ -1529,7 +1525,6 @@ def execute(self):
             )
             small_items: List[List[dict]] = sort_response["small"]
             try:
-                nest_asyncio.apply()
                 annotations = asyncio.run(self.run_workers(large_items, small_items))
             except Exception as e:
                 logger.error(e)
@@ -1707,7 +1702,6 @@ def execute(self):
                 ).data
             if not folders:
                 folders.append(self._folder)
-            nest_asyncio.apply()
             for folder in folders:
                 if self._item_names:
                     items = get_or_raise(

src/superannotate/lib/core/usecases/classes.py

@@ -6,6 +6,7 @@
 from lib.core.conditions import CONDITION_EQ as EQ
 from lib.core.entities import AnnotationClassEntity
 from lib.core.entities import ProjectEntity
+from lib.core.entities.classes import GroupTypeEnum
 from lib.core.enums import ProjectType
 from lib.core.exceptions import AppException
 from lib.core.serviceproviders import BaseServiceProvider
@@ -66,6 +67,13 @@ def validate_project_type(self):
                 "Predefined tagging functionality is not supported for projects"
                 f" of type {ProjectType.get_name(self._project.type)}."
             )
+        if self._project.type != ProjectType.VECTOR:
+            for g in self._annotation_class.attribute_groups:
+                if g.group_type == GroupTypeEnum.OCR:
+                    raise AppException(
+                        f"OCR attribute group is not supported for project type "
+                        f"{ProjectType.get_name(self._project.type)}."
+                    )
 
     def validate_default_value(self):
         if self._project.type == ProjectType.PIXEL.value and any(
@@ -109,13 +117,19 @@ def __init__(
         self._annotation_classes = annotation_classes
 
     def validate_project_type(self):
-        if self._project.type == ProjectType.PIXEL and any(
-            [True for i in self._annotation_classes if i.type == "tag"]
-        ):
-            raise AppException(
-                f"Predefined tagging functionality is not supported"
-                f" for projects of type {ProjectType.get_name(self._project.type)}."
-            )
+        if self._project.type != ProjectType.VECTOR:
+            for c in self._annotation_classes:
+                if self._project.type == ProjectType.PIXEL and c.type == "tag":
+                    raise AppException(
+                        f"Predefined tagging functionality is not supported"
+                        f" for projects of type {ProjectType.get_name(self._project.type)}."
+                    )
+                for g in c.attribute_groups:
+                    if g.group_type == GroupTypeEnum.OCR:
+                        raise AppException(
+                            f"OCR attribute group is not supported for project type "
+                            f"{ProjectType.get_name(self._project.type)}."
+                        )
 
     def validate_default_value(self):
         if self._project.type == ProjectType.PIXEL.value:

tests/integration/classes/test_classes_serialization.py

@@ -78,6 +78,6 @@ def test_group_type_wrong_arg(self):
                 "'radio',",
                 "'checklist',",
                 "'numeric',",
-                "'text'",
+                "'text',",
                 "'ocr'",
             ] == wrap_error(e).split()

tests/integration/classes/test_create_annotation_class.py

@@ -245,6 +245,71 @@ def test_create_annotation_class(self):
                 "Predefined tagging functionality is not supported for projects of type Video.",
             )
 
+    def test_create_annotation_class_via_ocr_group_type(self):
+        with self.assertRaisesRegexp(
+            AppException,
+            f"OCR attribute group is not supported for project type {self.PROJECT_TYPE}.",
+        ):
+            attribute_groups = [
+                {
+                    "id": 21448,
+                    "class_id": 56820,
+                    "name": "Large",
+                    "group_type": "ocr",
+                    "is_multiselect": 0,
+                    "createdAt": "2020-09-29T10:39:39.000Z",
+                    "updatedAt": "2020-09-29T10:39:39.000Z",
+                    "attributes": [],
+                }
+            ]
+            sa.create_annotation_class(
+                self.PROJECT_NAME,
+                "test_add",
+                "#FF0000",
+                attribute_groups,
+                class_type="tag",
+            )
+
+    def test_create_annotation_class_via_json_and_ocr_group_type(self):
+        with tempfile.TemporaryDirectory() as tmpdir_name:
+            temp_path = f"{tmpdir_name}/new_classes.json"
+            with open(temp_path, "w") as new_classes:
+                new_classes.write(
+                    """
+                    [
+                       {
+                          "id":56820,
+                          "project_id":7617,
+                          "name":"Personal vehicle",
+                          "color":"#547497",
+                          "count":18,
+                          "createdAt":"2020-09-29T10:39:39.000Z",
+                          "updatedAt":"2020-09-29T10:48:18.000Z",
+                          "type": "tag",
+                          "attribute_groups":[
+                             {
+                                "id":21448,
+                                "class_id":56820,
+                                "name":"Large",
+                                "group_type": "ocr",
+                                "is_multiselect":0,
+                                "createdAt":"2020-09-29T10:39:39.000Z",
+                                "updatedAt":"2020-09-29T10:39:39.000Z",
+                                "attributes":[]
+                             }
+                          ]
+                       }
+                    ]
+                    """
+                )
+            with self.assertRaisesRegexp(
+                AppException,
+                f"OCR attribute group is not supported for project type {self.PROJECT_TYPE}.",
+            ):
+                sa.create_annotation_classes_from_classes_json(
+                    self.PROJECT_NAME, temp_path
+                )
+
 
 class TestCreateAnnotationClassPixel(BaseTestCase):
     PROJECT_NAME = "TestCreateAnnotationClassPixel"

tests/unit/test_async_functions.py

@@ -7,6 +7,25 @@
 sa = SAClient()
 
 
+class DummyIterator:
+    def __init__(self, delay, to):
+        self.delay = delay
+        self.i = 0
+        self.to = to
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        i = self.i
+        if i >= self.to:
+            raise StopAsyncIteration
+        self.i += 1
+        if i:
+            await asyncio.sleep(self.delay)
+        return i
+
+
 class TestAsyncFunctions(TestCase):
     PROJECT_NAME = "TestAsync"
     PROJECT_DESCRIPTION = "Desc"
@@ -26,37 +45,37 @@ def setUpClass(cls):
     def tearDownClass(cls):
         sa.delete_project(cls.PROJECT_NAME)
 
+    @staticmethod
+    async def nested():
+        annotations = sa.get_annotations(TestAsyncFunctions.PROJECT_NAME)
+        assert len(annotations) == 4
+
     def test_get_annotations_in_running_event_loop(self):
         async def _test():
             annotations = sa.get_annotations(self.PROJECT_NAME)
             assert len(annotations) == 4
 
         asyncio.run(_test())
 
-    def test_multiple_get_annotations_in_running_event_loop(self):
-        #  TODO add handling of nested loop
-        async def nested():
-            sa.attach_items(self.PROJECT_NAME, self.ATTACH_PAYLOAD)
-            annotations = sa.get_annotations(self.PROJECT_NAME)
-            assert len(annotations) == 4
-
-        async def create_task_test():
-            import nest_asyncio
+    def test_create_task_get_annotations_in_running_event_loop(self):
+      async def _test():
+          task1 = asyncio.create_task(self.nested())
+          task2 = asyncio.create_task(self.nested())
+          await task1
+          await task2
 
-            nest_asyncio.apply()
-            task1 = asyncio.create_task(nested())
-            task2 = asyncio.create_task(nested())
-            await task1
-            await task2
-
-        asyncio.run(create_task_test())
+        asyncio.run(_test())
 
+    def test_gather_get_annotations_in_running_event_loop(self):
         async def gather_test():
-            import nest_asyncio
-
-            nest_asyncio.apply()
-            await asyncio.gather(nested(), nested())
+            await asyncio.gather(self.nested(), self.nested())
+        asyncio.run(gather_test())
 
+    def test_gather_async_for(self):
+        async def gather_test():
+            async for _ in DummyIterator(delay=0.01, to=2):
+                annotations = sa.get_annotations(TestAsyncFunctions.PROJECT_NAME)
+                assert len(annotations) == 4
         asyncio.run(gather_test())
 
     def test_upload_annotations_in_running_event_loop(self):