finalizing this delete items

Author: VahagnTKA

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

@@ -650,7 +650,7 @@ def set_images_annotation_statuses(
         logger.info("Annotations status of images changed")
 
     def delete_images(
-        self, project: Union[NotEmptyStr, dict], image_names: Optional[list[str]] = None
+        self, project: Union[NotEmptyStr, dict], image_names: Optional[List[str]] = None
     ):
         """delete images in project.
 
@@ -694,19 +694,12 @@ def delete_items(
         """
         project_name, folder_name = extract_project_folder(project)
 
-        ## Type checking should be done in controller or by PyDantic?
-        # if not isinstance(image_names, list) and image_names is not None:
-        #     raise AppException("Image_names should be a list of str or None.")
-
         response = self.controller.delete_items(
             project_name=project_name, folder_name=folder_name, items=items
         )
         if response.errors:
             raise AppException(response.errors)
 
-        logger.info(
-            f"Items deleted in project {project_name}{'/' + folder_name if folder_name else ''}"
-        )
 
     def assign_items(
         self, project: Union[NotEmptyStr, dict], items: List[str], user: str
@@ -718,8 +711,10 @@ def assign_items(
 
         :param project: project name or folder path (e.g., "project1/folder1")
         :type project: str
+
         :param items: list of items to assign
-        :type item_names: list of str
+        :type items: list of str
+
         :param user: user email
         :type user: str
         """
@@ -728,9 +723,7 @@ def assign_items(
 
         response = self.controller.assign_items(project_name, folder_name, items, user)
 
-        if not response.errors:
-            logger.info(f"Assign items to user {user}")
-        else:
+        if response.errors:
             raise AppException(response.errors)
 
     def unassign_items(
@@ -743,7 +736,7 @@ def unassign_items(
         :param project: project name or folder path (e.g., "project1/folder1")
         :type project: str
         :param items: list of items to unassign
-        :type item_names: list of str
+        :type items: list of str
         """
         project_name, folder_name = extract_project_folder(project)
 

src/superannotate/lib/core/service_types.py

@@ -79,11 +79,13 @@ def __init__(self, response, content_type=None):
             "reason": response.reason,
             "content": response.content,
         }
-        if response.ok:
+        try:
             if content_type and content_type is not self.__class__:
                 data["data"] = content_type(**response.json())
             else:
                 data["data"] = response.json()
+        except Exception as e:
+            data["data"] = {}
         super().__init__(**data)
 
     @property
@@ -92,5 +94,8 @@ def ok(self):
 
     @property
     def error(self):
-        default_message = self.data["reason"] if self.data["reason"] else "Unknown error"
-        return getattr(self.data, "error", default_message)
+        default_message = self.reason if self.reason else "Unknown Error"
+        if isinstance(self.data, dict):
+            return self.data.get("error", default_message)
+        else:
+            return getattr(self.data, "error", default_message)

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,
@@ -182,7 +185,7 @@ def assign_items(
         folder_name: str,
         user: str,
         item_names: list,
-    ):
+    ) -> ServiceResponse:
         raise NotImplementedError
 
     def get_bulk_images(

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

@@ -1,7 +1,7 @@
 import copy
 from typing import List
 
-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
@@ -20,11 +20,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__(
@@ -43,22 +76,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
 
@@ -104,7 +137,7 @@ def validate_query(self):
             self._query = response["parsedQuery"]
         else:
             raise AppException("Incorrect query.")
-        if self._project.sync_status != constances.ProjectState.SYNCED.value:
+        if self._project.sync_status != constants.ProjectState.SYNCED.value:
             raise AppException("Data is not synced.")
 
     def execute(self) -> Response:
@@ -210,33 +243,31 @@ def __init__(
         self._user = user
         self._service = service
 
-    def validate_user(
+    def validate_item_names(
         self,
     ):
-
-        for c in self._project.users:
-            if c["user_id"] == self._user:
-                return True
-
-        raise AppValidationException(
-            f"{self._user} is not a verified contributor for the {self._project.name}"
-        )
+        self._item_names = list(set(self._item_names))
 
     def execute(self):
+        cnt_assigned = 0
+        total_count = len(self._item_names)
         if self.is_valid():
             for i in range(0, len(self._item_names), self.CHUNK_SIZE):
-                is_assigned = self._service.assign_items(
+                response = self._service.assign_items(
                     team_id=self._project.team_id,
                     project_id=self._project.id,
                     folder_name=self._folder.name,
                     user=self._user,
                     item_names=self._item_names[i : i + self.CHUNK_SIZE],  # noqa: E203
                 )
-                if not is_assigned:
-                    self._response.errors = AppException(
-                        f"Cant assign {', '.join(self._item_names[i: i + self.CHUNK_SIZE])}"
-                    )
-                    continue
+                if not response.ok and response.error:  # User not found
+                    self._response.errors += response.error
+                    return self._response
+
+                cnt_assigned += response.data["successCount"]
+            logger.info(
+                f"Assigned {cnt_assigned}/{total_count} items to user {self._user}"
+            )
         return self._response
 
 
@@ -284,13 +315,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
@@ -313,18 +344,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():
@@ -411,9 +442,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:
@@ -539,9 +570,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():
@@ -599,7 +630,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
@@ -651,3 +682,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

@@ -847,7 +847,8 @@ def delete_items(
         use_case = usecases.DeleteItemsUseCase(
             project=project,
             folder=folder,
-            items=items,
+            items=self.items,
+            item_names=items,
             backend_service_provider=self._backend_client,
         )
         return use_case.execute()