Merge pull request #454 from superannotateai/1028_delete_items

1028 delete items

Author: VaghinakDev

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

@@ -652,17 +652,25 @@ def set_images_annotation_statuses(
     def delete_images(
         self, project: Union[NotEmptyStr, dict], image_names: Optional[List[str]] = None
     ):
-        """Delete images in project.
+        """Delete Images in project.
 
         :param project: project name or folder path (e.g., "project1/folder1")
         :type project: str
         :param image_names: to be deleted images' names. If None, all the images will be deleted
         :type image_names: list of strs
         """
+
+        warning_msg = (
+            "We're deprecating the delete_images function. Please use delete_items instead."
+            "Learn more. \n"
+            "https://superannotate.readthedocs.io/en/stable/superannotate.sdk.html#superannotate.delete_items"
+        )
+        logger.warning(warning_msg)
+        warnings.warn(warning_msg, DeprecationWarning)
         project_name, folder_name = extract_project_folder(project)
 
         if not isinstance(image_names, list) and image_names is not None:
-            raise AppException("Image_names should be a list of str or None.")
+            raise AppException("image_names should be a list of str or None.")
 
         response = self.controller.delete_images(
             project_name=project_name, folder_name=folder_name, image_names=image_names
@@ -674,6 +682,25 @@ def delete_images(
             f"Images deleted in project {project_name}{'/' + folder_name if folder_name else ''}"
         )
 
+    def delete_items(
+        self, project: str, items: Optional[List[str]] = None
+    ):
+        """Delete items in a given project.
+
+        :param project: project name or folder path (e.g., "project1/folder1")
+        :type project: str
+        :param items: to be deleted items' names. If None, all the items will be deleted
+        :type items: list of str
+        """
+        project_name, folder_name = extract_project_folder(project)
+
+        response = self.controller.delete_items(
+            project_name=project_name, folder_name=folder_name, items=items
+        )
+        if response.errors:
+            raise AppException(response.errors)
+
+
     def assign_items(
         self, project: Union[NotEmptyStr, dict], items: List[str], user: str
     ):

src/superannotate/lib/core/serviceproviders.py

@@ -165,6 +165,9 @@ def set_images_statuses_bulk(
     def delete_images(self, project_id: int, team_id: int, image_ids: List[int]):
         raise NotImplementedError
 
+    def delete_items(self, project_id: int, team_id: int, item_ids: List[int]):
+        raise NotImplementedError
+
     def assign_images(
         self,
         team_id: int,

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

@@ -2,7 +2,7 @@
 from typing import List
 from typing import Optional
 
-import superannotate.lib.core as constances
+import superannotate.lib.core as constants
 from lib.core.conditions import Condition
 from lib.core.conditions import CONDITION_EQ as EQ
 from lib.core.entities import AttachmentEntity
@@ -22,10 +22,44 @@
 from lib.core.serviceproviders import SuperannotateServiceProvider
 from lib.core.usecases.base import BaseReportableUseCase
 from lib.core.usecases.base import BaseUseCase
+from lib.core.entities import ImageEntity
 from superannotate.logger import get_default_logger
 
 logger = get_default_logger()
 
+class GetBulkItems(BaseUseCase):
+    def __init__(
+        self,
+        service: SuperannotateServiceProvider,
+        project_id: int,
+        team_id: int,
+        folder_id: int,
+        items: List[str],
+    ):
+        super().__init__()
+        self._service = service
+        self._project_id = project_id
+        self._team_id = team_id
+        self._folder_id = folder_id
+        self._items = items
+        self._chunk_size = 500
+
+    def execute(self):
+        res = []
+        for i in range(0, len(self._items), self._chunk_size):
+            response = self._service.get_bulk_items(
+                project_id=self._project_id,
+                team_id=self._team_id,
+                folder_id=self._folder_id,
+                items=self._items[i : i + self._chunk_size],  # noqa: E203
+            )
+
+            if not response.ok:
+                raise AppException(response.error)
+            #TODO stop using Image Entity when it gets deprecated and from_dict gets implemented for items
+            res += [ImageEntity.from_dict(**item) for item in response.data]
+        self._response.data = res
+        return self._response
 
 class GetItem(BaseReportableUseCase):
     def __init__(
@@ -44,22 +78,22 @@ def __init__(
 
     @staticmethod
     def serialize_entity(entity: Entity, project: ProjectEntity):
-        if project.upload_state != constances.UploadState.EXTERNAL.value:
+        if project.upload_state != constants.UploadState.EXTERNAL.value:
             entity.url = None
         if project.type in (
-            constances.ProjectType.VECTOR.value,
-            constances.ProjectType.PIXEL.value,
+            constants.ProjectType.VECTOR.value,
+            constants.ProjectType.PIXEL.value,
         ):
             tmp_entity = entity
-            if project.type == constances.ProjectType.VECTOR.value:
+            if project.type == constants.ProjectType.VECTOR.value:
                 entity.segmentation_status = None
-            if project.upload_state == constances.UploadState.EXTERNAL.value:
+            if project.upload_state == constants.UploadState.EXTERNAL.value:
                 tmp_entity.prediction_status = None
                 tmp_entity.segmentation_status = None
             return TmpImageEntity(**tmp_entity.dict(by_alias=True))
-        elif project.type == constances.ProjectType.VIDEO.value:
+        elif project.type == constants.ProjectType.VIDEO.value:
             return VideoEntity(**entity.dict(by_alias=True))
-        elif project.type == constances.ProjectType.DOCUMENT.value:
+        elif project.type == constants.ProjectType.DOCUMENT.value:
             return DocumentEntity(**entity.dict(by_alias=True))
         return entity
 
@@ -320,13 +354,13 @@ def __init__(
         attachments: List[AttachmentEntity],
         annotation_status: str,
         backend_service_provider: SuperannotateServiceProvider,
-        upload_state_code: int = constances.UploadState.EXTERNAL.value,
+        upload_state_code: int = constants.UploadState.EXTERNAL.value,
     ):
         super().__init__(reporter)
         self._project = project
         self._folder = folder
         self._attachments = attachments
-        self._annotation_status_code = constances.AnnotationStatus.get_value(
+        self._annotation_status_code = constants.AnnotationStatus.get_value(
             annotation_status
         )
         self._upload_state_code = upload_state_code
@@ -349,18 +383,18 @@ def validate_limitations(self):
         if not response.ok:
             raise AppValidationException(response.error)
         if attachments_count > response.data.folder_limit.remaining_image_count:
-            raise AppValidationException(constances.ATTACH_FOLDER_LIMIT_ERROR_MESSAGE)
+            raise AppValidationException(constants.ATTACH_FOLDER_LIMIT_ERROR_MESSAGE)
         elif attachments_count > response.data.project_limit.remaining_image_count:
-            raise AppValidationException(constances.ATTACH_PROJECT_LIMIT_ERROR_MESSAGE)
+            raise AppValidationException(constants.ATTACH_PROJECT_LIMIT_ERROR_MESSAGE)
         elif (
             response.data.user_limit
             and attachments_count > response.data.user_limit.remaining_image_count
         ):
-            raise AppValidationException(constances.ATTACH_USER_LIMIT_ERROR_MESSAGE)
+            raise AppValidationException(constants.ATTACH_USER_LIMIT_ERROR_MESSAGE)
 
     def validate_upload_state(self):
-        if self._project.upload_state == constances.UploadState.BASIC.value:
-            raise AppValidationException(constances.ATTACHING_UPLOAD_STATE_ERROR)
+        if self._project.upload_state == constants.UploadState.BASIC.value:
+            raise AppValidationException(constants.ATTACHING_UPLOAD_STATE_ERROR)
 
     @staticmethod
     def generate_meta():
@@ -447,9 +481,9 @@ def _validate_limitations(self, items_count):
         if not response.ok:
             raise AppValidationException(response.error)
         if items_count > response.data.folder_limit.remaining_image_count:
-            raise AppValidationException(constances.COPY_FOLDER_LIMIT_ERROR_MESSAGE)
+            raise AppValidationException(constants.COPY_FOLDER_LIMIT_ERROR_MESSAGE)
         if items_count > response.data.project_limit.remaining_image_count:
-            raise AppValidationException(constances.COPY_PROJECT_LIMIT_ERROR_MESSAGE)
+            raise AppValidationException(constants.COPY_PROJECT_LIMIT_ERROR_MESSAGE)
 
     def validate_item_names(self):
         if self._item_names:
@@ -575,9 +609,9 @@ def _validate_limitations(self, items_count):
         if not response.ok:
             raise AppValidationException(response.error)
         if items_count > response.data.folder_limit.remaining_image_count:
-            raise AppValidationException(constances.MOVE_FOLDER_LIMIT_ERROR_MESSAGE)
+            raise AppValidationException(constants.MOVE_FOLDER_LIMIT_ERROR_MESSAGE)
         if items_count > response.data.project_limit.remaining_image_count:
-            raise AppValidationException(constances.MOVE_PROJECT_LIMIT_ERROR_MESSAGE)
+            raise AppValidationException(constants.MOVE_PROJECT_LIMIT_ERROR_MESSAGE)
 
     def execute(self):
         if self.is_valid():
@@ -635,7 +669,7 @@ def __init__(
         self._folder = folder
         self._item_names = item_names
         self._items = items
-        self._annotation_status_code = constances.AnnotationStatus.get_value(
+        self._annotation_status_code = constants.AnnotationStatus.get_value(
             annotation_status
         )
         self._backend_service = backend_service_provider
@@ -687,3 +721,57 @@ def execute(self):
                     self._response.errors = AppException(self.ERROR_MESSAGE)
                     break
         return self._response
+
+class DeleteItemsUseCase(BaseUseCase):
+    CHUNK_SIZE = 1000
+
+    def __init__(
+        self,
+        project: ProjectEntity,
+        folder: FolderEntity,
+        backend_service_provider: SuperannotateServiceProvider,
+        items: BaseReadOnlyRepository,
+        item_names: List[str] = None,
+    ):
+        super().__init__()
+        self._project = project
+        self._folder = folder
+        self._items = items
+        self._backend_service = backend_service_provider
+        self._item_names = item_names
+
+    def execute(self):
+        if self.is_valid():
+            if self._item_names:
+                item_ids = [
+                    item.uuid
+                    for item in GetBulkItems(
+                        service=self._backend_service,
+                        project_id=self._project.id,
+                        team_id=self._project.team_id,
+                        folder_id=self._folder.uuid,
+                        items=self._item_names,
+                    )
+                    .execute()
+                    .data
+                ]
+            else:
+                condition = (
+                    Condition("team_id", self._project.team_id, EQ)
+                    & Condition("project_id", self._project.id, EQ)
+                    & Condition("folder_id", self._folder.uuid, EQ)
+                )
+                item_ids = [item.id for item in self._items.get_all(condition)]
+
+            for i in range(0, len(item_ids), self.CHUNK_SIZE):
+                response = self._backend_service.delete_items(
+                    project_id=self._project.id,
+                    team_id=self._project.team_id,
+                    item_ids=item_ids[i : i + self.CHUNK_SIZE],  # noqa: E203
+                )
+
+            logger.info(
+                f"Items deleted in project {self._project.name}{'/' + self._folder.name if not self._folder.is_root else ''}"
+            )
+
+        return self._response

src/superannotate/lib/infrastructure/controller.py

@@ -835,6 +835,24 @@ def delete_images(
         )
         return use_case.execute()
 
+    def delete_items(
+        self,
+        project_name: str,
+        folder_name: str,
+        items: List[str] = None,
+    ):
+        project = self._get_project(project_name)
+        folder = self._get_folder(project, folder_name)
+
+        use_case = usecases.DeleteItemsUseCase(
+            project=project,
+            folder=folder,
+            items=self.items,
+            item_names=items,
+            backend_service_provider=self._backend_client,
+        )
+        return use_case.execute()
+
     def assign_items(
         self, project_name: str, folder_name: str, item_names: list, user: str
     ):

src/superannotate/lib/infrastructure/services.py

@@ -203,7 +203,9 @@ class SuperannotateBackendService(BaseBackendService):
     URL_GET_IMAGES = "images"
     URL_GET_ITEMS = "items"
     URL_BULK_GET_IMAGES = "images/getBulk"
+    URL_BULK_GET_ITEMS = "images/getBulk"
     URL_DELETE_FOLDERS = "image/delete/images"
+    URL_DELETE_ITEMS = "image/delete/images"
     URL_CREATE_IMAGE = "image/ext-create"
     URL_PROJECT_SETTINGS = "project/{}/settings"
     URL_PROJECT_WORKFLOW = "project/{}/workflow"
@@ -710,6 +712,23 @@ def get_bulk_images(
         )
         return res.json()
 
+    def get_bulk_items(
+        self, project_id: int, team_id: int, folder_id: int, items: List[str]
+    ) -> List[dict]:
+
+        bulk_get_items_url = urljoin(self.api_url, self.URL_BULK_GET_ITEMS)
+        res = self._request(
+            bulk_get_items_url,
+            "post",
+            data={
+                "project_id": project_id,
+                "team_id": team_id,
+                "folder_id": folder_id,
+                "names": items,
+            },
+        )
+        return ServiceResponse(res, ServiceResponse)
+
     def delete_images(self, project_id: int, team_id: int, image_ids: List[int]):
         delete_images_url = urljoin(self.api_url, self.URL_DELETE_FOLDERS)
         res = self._request(
@@ -720,6 +739,18 @@ def delete_images(self, project_id: int, team_id: int, image_ids: List[int]):
         )
         return res.json()
 
+    def delete_items(self, project_id: int, team_id: int, item_ids: List[int]):
+        delete_items_url = urljoin(self.api_url, self.URL_DELETE_ITEMS)
+
+        res = self._request(
+            delete_items_url,
+            "put",
+            params={"team_id": team_id, "project_id": project_id},
+            data={"image_ids": item_ids},
+        )
+
+        return ServiceResponse(res, ServiceResponse)
+
     def assign_images(
         self,
         team_id: int,