Merge branch 'develop' of https://github.com/superannotateai/superannotate-python-sdk into develop

Author: Vaghinak Basentsyan

src/superannotate/lib/core/usecases.py

@@ -1684,13 +1684,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 = (
@@ -4010,7 +4013,7 @@ def __init__(
         self._folder = folder
 
     def validate_project_type(self):
-        if self._project.project_type is not ProjectType.PIXEL:
+        if self._project.project_type is not ProjectType.PIXEL.value:
             raise AppValidationException(
                 "Operation not supported for given project type"
             )
@@ -4020,59 +4023,77 @@ def validate_model(self):
             raise AppValidationException("Model Does not exist")
 
     def validate_upload_state(self):
+
         if self._project.upload_state is constances.UploadState.EXTERNAL:
             raise AppValidationException(
                 "The function does not support projects containing images attached with URLs"
             )
 
     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,
-        )
+        if self.is_valid():
+            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]
 
-        res = self._service.run_segmentation(
-            self._project.team_id,
-            self._project.uuid,
-            model_name=self._ml_model_name,
-            image_ids=image_ids,
-        )
-        if not res.ok:
-            return self._response
+            if not len(image_names):
+                self._response.errors = AppException(
+                    "No valid image names were provided."
+                )
+                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,
+            res = self._service.run_segmentation(
+                self._project.team_id,
+                self._project.uuid,
+                model_name=self._ml_model_name,
+                image_ids=image_ids,
             )
+            if not res.ok:
+                return self._response
 
-            succeded_imgs = [
-                img["name"]
-                for img in images_metadata
-                if img["segmentation_status"] == 3
-            ]
-            failed_imgs = [
-                img["name"]
-                for img in images_metadata
-                if img["segmentation_status"] == 4
-            ]
+            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
+                )
 
-            complete_images = succeded_imgs + failed_imgs
-            logger.info(
-                f"segmentation complete on {len(complete_images)} / {len(image_ids)} images"
-            )
-            time.sleep(5)
+                success_images = [
+                    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.segmentation_status
+                    == constances.SegmentationStatus.FAILED.value
+                ]
+                logger.info(
+                    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
 
 
@@ -4095,63 +4116,82 @@ 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,
-        )
-
-        image_ids = [image["id"] for image in images]
-        image_names = [image["name"] for image in images]
+        if self.is_valid():
+            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
+            )
 
-        if not image_ids:
-            self._response.errors = AppException("No valid image names were provided.")
-            return self._response
+            image_ids = [image.uuid for image in images]
+            image_names = [image.name for image in images]
 
-        ml_models = self._ml_model_repo.get_all(
-            condition=Condition("name", self._ml_model_name, EQ)
-            & Condition("include_global", True, EQ)
-            & Condition("team_id", self._project.team_id, EQ)
-        )
-        ml_model = None
-        for model in ml_models:
-            if model.name == self._ml_model_name:
-                ml_model = model
+            if not len(image_names):
+                self._response.errors = AppException(
+                    "No valid image names were provided."
+                )
+                return self._response
 
-        res = self._service.run_prediction(
-            team_id=self._project.team_id,
-            project_id=self._project.uuid,
-            ml_model_id=ml_model.uuid,
-            image_ids=image_ids,
-        )
-        if not res.ok:
-            return self._response
+            ml_models = self._ml_model_repo.get_all(
+                condition=Condition("name", self._ml_model_name, EQ)
+                & Condition("include_global", True, EQ)
+                & Condition("team_id", self._project.team_id, EQ)
+            )
+            ml_model = None
+            for model in ml_models:
+                if model.name == self._ml_model_name:
+                    ml_model = model
 
-        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,
+            res = self._service.run_prediction(
                 team_id=self._project.team_id,
-                folder_id=self._folder.uuid,
-                images=image_names,
+                project_id=self._project.uuid,
+                ml_model_id=ml_model.uuid,
+                image_ids=image_ids,
             )
+            if not res.ok:
+                return self._response
 
-            success_images = [
-                img["name"] for img in images_metadata if img["prediction_status"] == 3
-            ]
-            failed_images = [
-                img["name"] for img in images_metadata if img["prediction_status"] == 4
-            ]
+            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
+                )
 
-            complete_images = success_images + failed_images
-            logger.info(
-                f"prediction complete on {len(complete_images)} / {len(image_ids)} images"
-            )
-            time.sleep(5)
+                success_images = [
+                    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.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"
+                )
+                time.sleep(5)
 
-        self._response.data = (success_images, failed_images)
+            self._response.data = (success_images, failed_images)
         return self._response
 
 
@@ -4417,13 +4457,25 @@ def images_to_upload(self):
                 folder_id=self._folder.uuid,
                 images=[Path(image).name for image in paths],
             )
-            image_names = [image["name"] for image in images]
+            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
+            )
 
             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)
@@ -4548,10 +4600,19 @@ def execute(self) -> Response:
                         continue
                     else:
                         polling_states[poll_id] = True
-                        logger.info("Annotations deleted")
                         continue
+
+            project_folder_name = (
+                self._project.name
+                + (f"/{self._folder.name}" if self._folder.name != "root" else "")
+                + "."
+            )
+
             if all(polling_states.values()):
-                logger.info("Annotations deleted")
+                logger.info(
+                    "The annotations have been successfully deleted from "
+                    + project_folder_name
+                )
             else:
                 logger.info("Annotations delete fails.")
         return self._response