Fix 500

Author: dshabin

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

@@ -619,9 +619,15 @@ def _upload_image(image_url, image_name=None) -> ProcessedImage:
         if not download_response.errors:
             content, content_name = download_response.data
             image_name = image_name if image_name else content_name
-            if image_name not in controller.get_duplicated_images(
-                project_name=project_name, folder_name=folder_name, images=[image_name]
-            ):
+            duplicated_images = [
+                image.name
+                for image in controller.get_duplicated_images(
+                    project_name=project_name,
+                    folder_name=folder_name,
+                    images=[image_name],
+                )
+            ]
+            if image_name not in duplicated_images:
                 upload_response = controller.upload_image_to_s3(
                     project_name=project_name,
                     image_path=image_name,

src/superannotate/lib/core/entities.py

@@ -4,6 +4,8 @@
 from typing import Iterable
 from typing import List
 
+from src.superannotate.lib.core.enums import SegmentationStatus
+
 
 class BaseEntity(ABC):
     def __init__(self, uuid: Any = None):
@@ -233,6 +235,8 @@ def __init__(
         entropy_value: int = None,
         approval_status: bool = None,
         is_pinned: bool = None,
+        segmentation_status: int = SegmentationStatus.NOT_STARTED.value,
+        prediction_status: int = SegmentationStatus.NOT_STARTED.value,
         meta: ImageInfoEntity = ImageInfoEntity(),
     ):
         super().__init__(uuid)
@@ -250,6 +254,8 @@ def __init__(
         self.approval_status = approval_status
         self.annotator_name = annotator_name
         self.is_pinned = is_pinned
+        self.segmentation_status = segmentation_status
+        self.prediction_status = prediction_status
         self.meta = meta
 
     def to_dict(self):
@@ -268,6 +274,8 @@ def to_dict(self):
             "annotator_id": self.annotator_id,
             "annotator_name": self.annotator_name,
             "is_pinned": self.is_pinned,
+            "segmentation_status": self.segmentation_status,
+            "prediction_status": self.prediction_status,
             "meta": self.meta.to_dict(),
         }
 

src/superannotate/lib/core/usecases.py

@@ -1634,13 +1634,16 @@ def execute(self):
         if self.is_valid():
             if self._image_names:
                 image_ids = [
-                    image["id"]
-                    for image in self._backend_service.get_bulk_images(
+                    image.uuid
+                    for image in GetBulkImages(
+                        service=self._backend_service,
                         project_id=self._project.uuid,
                         team_id=self._project.team_id,
                         folder_id=self._folder.uuid,
                         images=self._image_names,
                     )
+                    .execute()
+                    .data
                 ]
             else:
                 condition = (
@@ -3971,15 +3974,23 @@ def validate_upload_state(self):
 
     def execute(self):
         if self.is_valid():
-            images = self._service.get_duplicated_images(
-                project_id=self._project.uuid,
-                team_id=self._project.team_id,
-                folder_id=self._folder.uuid,
-                images=self._images_list,
+            images = (
+                GetBulkImages(
+                    service=self._service,
+                    project_id=self._project.uuid,
+                    team_id=self._project.team_id,
+                    folder_id=self._folder.uuid,
+                    images=self._images_list,
+                )
+                .execute()
+                .data
             )
 
-            image_ids = [image["id"] for image in images]
-            image_names = [image["name"] for image in images]
+            image_ids = [image.uuid for image in images]
+            image_names = [image.name for image in images]
+
+            if not len(image_names):
+                raise AppException("No valid image names were provided")
 
             res = self._service.run_segmentation(
                 self._project.team_id,
@@ -3990,34 +4001,39 @@ def execute(self):
             if not res.ok:
                 return self._response
 
-            succeded_imgs = []
-            failed_imgs = []
-            while len(succeded_imgs) + len(failed_imgs) != len(image_ids):
-                images_metadata = self._service.get_bulk_images(
-                    project_id=self._project.uuid,
-                    team_id=self._project.team_id,
-                    folder_id=self._folder.uuid,
-                    images=image_names,
+            success_images = []
+            failed_images = []
+            while len(success_images) + len(failed_images) != len(image_ids):
+                images_metadata = (
+                    GetBulkImages(
+                        service=self._service,
+                        project_id=self._project.uuid,
+                        team_id=self._project.team_id,
+                        folder_id=self._folder.uuid,
+                        images=self._images_list,
+                    )
+                    .execute()
+                    .data
                 )
 
-                succeded_imgs = [
-                    img["name"]
+                success_images = [
+                    img.name
                     for img in images_metadata
-                    if img["segmentation_status"] == 3
+                    if img.segmentation_status
+                    == constances.SegmentationStatus.COMPLETED.value
                 ]
-                failed_imgs = [
-                    img["name"]
+                failed_images = [
+                    img.name
                     for img in images_metadata
-                    if img["segmentation_status"] == 4
+                    if img.segmentation_status
+                    == constances.SegmentationStatus.FAILED.value
                 ]
-
-                complete_images = succeded_imgs + failed_imgs
                 logger.info(
-                    f"segmentation complete on {len(complete_images)} / {len(image_ids)} images"
+                    f"segmentation complete on {len(success_images + failed_images)} / {len(image_ids)} images"
                 )
                 time.sleep(5)
 
-            self._response.data = (succeded_imgs, failed_imgs)
+            self._response.data = (success_images, failed_images)
         return self._response
 
 
@@ -4040,17 +4056,23 @@ def __init__(
         self._folder = folder
 
     def execute(self):
-        images = self._service.get_duplicated_images(
-            project_id=self._project.uuid,
-            team_id=self._project.team_id,
-            folder_id=self._folder.uuid,
-            images=self._images_list,
+
+        images = (
+            GetBulkImages(
+                service=self._service,
+                project_id=self._project.uuid,
+                team_id=self._project.team_id,
+                folder_id=self._folder.uuid,
+                images=self._images_list,
+            )
+            .execute()
+            .data
         )
 
-        image_ids = [image["id"] for image in images]
-        image_names = [image["name"] for image in images]
+        image_ids = [image.uuid for image in images]
+        image_names = [image.name for image in images]
 
-        if not image_ids:
+        if not len(image_names):
             self._response.errors = AppException("No valid image names were provided.")
             return self._response
 
@@ -4076,23 +4098,31 @@ def execute(self):
         success_images = []
         failed_images = []
         while len(success_images) + len(failed_images) != len(image_ids):
-            images_metadata = self._service.get_bulk_images(
-                project_id=self._project.uuid,
-                team_id=self._project.team_id,
-                folder_id=self._folder.uuid,
-                images=image_names,
+            images_metadata = (
+                GetBulkImages(
+                    service=self._service,
+                    project_id=self._project.uuid,
+                    team_id=self._project.team_id,
+                    folder_id=self._folder.uuid,
+                    images=self._images_list,
+                )
+                .execute()
+                .data
             )
 
             success_images = [
-                img["name"] for img in images_metadata if img["prediction_status"] == 3
+                img.name
+                for img in images_metadata
+                if img.segmentation_status
+                == constances.SegmentationStatus.COMPLETED.value
             ]
             failed_images = [
-                img["name"] for img in images_metadata if img["prediction_status"] == 4
+                img.name
+                for img in images_metadata
+                if img.segmentation_status == constances.SegmentationStatus.FAILED.value
             ]
-
-            complete_images = success_images + failed_images
             logger.info(
-                f"prediction complete on {len(complete_images)} / {len(image_ids)} images"
+                f"Prediction complete on {len(success_images + failed_images)} / {len(image_ids)} images"
             )
             time.sleep(5)
 
@@ -4357,20 +4387,25 @@ def images_to_upload(self):
             filtered_paths = []
             duplicated_paths = []
 
-            get_bulk_use_case = GetDuplicateImages(
-                service=self._backend_client,
-                project_id=self._project.uuid,
-                team_id=self._project.team_id,
-                folder_id=self._folder.uuid,
-                images=[Path(image).name for image in paths],
+            image_entities = (
+                GetBulkImages(
+                    service=self._backend_client,
+                    project_id=self._project.uuid,
+                    team_id=self._project.team_id,
+                    folder_id=self._folder.uuid,
+                    images=[Path(image).name for image in paths],
+                )
+                .execute()
+                .data
             )
-            image_names = get_bulk_use_case.execute()
 
             for path in paths:
                 not_in_exclude_list = [
                     x not in Path(path).name for x in self.exclude_file_patterns
                 ]
-                non_in_service_list = [x not in Path(path).name for x in image_names]
+                non_in_service_list = [
+                    x.name not in Path(path).name for x in image_entities
+                ]
                 if all(not_in_exclude_list) and all(non_in_service_list):
                     filtered_paths.append(path)
                 if not all(non_in_service_list):
@@ -4481,7 +4516,7 @@ def execute(self) -> Response:
         return self._response
 
 
-class GetDuplicateImages(BaseUseCase):
+class GetBulkImages(BaseUseCase):
     def __init__(
         self,
         service: SuerannotateServiceProvider,
@@ -4499,13 +4534,32 @@ def __init__(
         self._chunk_size = 500
 
     def execute(self):
-        duplicates = []
+        res = []
         for i in range(0, len(self._images), self._chunk_size):
-            duplications = self._service.get_bulk_images(
+            images = self._service.get_bulk_images(
                 project_id=self._project_id,
                 team_id=self._team_id,
                 folder_id=self._folder_id,
                 images=self._images[i : i + self._chunk_size],
             )
-            duplicates += [image["name"] for image in duplications]
-        return duplicates
+            res += [
+                ImageEntity(
+                    uuid=image["id"],
+                    name=image["name"],
+                    path=image["name"],
+                    project_id=image["project_id"],
+                    team_id=image["team_id"],
+                    annotation_status_code=image["annotation_status"],
+                    folder_id=image["folder_id"],
+                    annotator_id=image["annotator_id"],
+                    annotator_name=image["annotator_name"],
+                    qa_id=image["qa_id"],
+                    qa_name=image["qa_name"],
+                    entropy_value=image["entropy_value"],
+                    approval_status=image["approval_status"],
+                    is_pinned=image["is_pinned"],
+                )
+                for image in images
+            ]
+        self._response.data = res
+        return self._response

src/superannotate/lib/infrastructure/controller.py

@@ -1476,11 +1476,11 @@ def get_duplicated_images(
     ):
         project = self._get_project(project_name)
         folder = self._get_folder(project, folder_name)
-        use_case = usecases.GetDuplicateImages(
+        use_case = usecases.GetBulkImages(
             service=self._backend_client,
             project_id=project.uuid,
             team_id=project.team_id,
             folder_id=folder.uuid,
             images=images,
         )
-        return use_case.execute()
+        return use_case.execute().data