superannotate 4.4.25.dev2__tar.gz → 4.4.26.dev1__tar.gz

{superannotate-4.4.25.dev2/src/superannotate.egg-info → superannotate-4.4.26.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: superannotate
-Version: 4.4.25.dev2
+Version: 4.4.26.dev1
 Summary: Python SDK to SuperAnnotate platform
 Home-page: https://github.com/superannotateai/superannotate-python-sdk
 Author: SuperAnnotate AI

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/__init__.py

@@ -3,7 +3,7 @@ import os
 import sys
 
 
-__version__ = "4.4.25dev2"
+__version__ = "4.4.26dev1"
 
 os.environ.update({"sa_version": __version__})
 sys.path.append(os.path.split(os.path.realpath(__file__))[0])
@@ -18,7 +18,7 @@ from lib.core.exceptions import AppException
 from lib.app.input_converters import convert_project_type
 from lib.app.input_converters import export_annotation
 from lib.app.input_converters import import_annotation
-from lib.app.interface.sdk_interface import SAClient
+from superannotate.lib.app.interface.sdk_interface import SAClient
 
 
 SESSIONS = {}

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/app/interface/sdk_interface.py

@@ -79,7 +79,7 @@ PROJECT_TYPE = Literal[
     "Document",
     "Tiled",
     "PointCloud",
-    "GenAI",
+    "Multimodal",
 ]
 
 
@@ -307,7 +307,7 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
         :param project_description: the new project's description
         :type project_description: str
 
-        :param project_type: the new project type, Vector, Pixel, Video, Document, Tiled, PointCloud, GenAI.
+        :param project_type: the new project type, Vector, Pixel, Video, Document, Tiled, PointCloud, Multimodal.
         :type project_type: str
 
         :param settings: list of settings objects
@@ -711,8 +711,8 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
         """
         warnings.warn(
             DeprecationWarning(
-                "The “set_project_workflow” function is deprecated."
-                " Please use the “set_project_steps” function instead."
+                "The “get_project_workflow” function is deprecated."
+                " Please use the “get_project_steps” function instead."
             )
         )
         return self.get_project_steps(project)
@@ -1215,11 +1215,11 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
         :param only_pinned: enable only pinned output in export. This option disables all other types of output.
         :type only_pinned: bool
 
-        :param kwargs:
-             Arbitrary kwargs:
+        :param kwargs: Arbitrary keyword arguments:
 
-             - integration_name: can be provided which will be used as a storage to store export file
-             - format: can be CSV for the Gen AI projects
+             - integration_name: The name of the integration within the platform that is being used.
+             - format: The format in which the data will be exported in multimodal projects.
+               It can be either CSV or JSON. If None, the data will be exported in the default JSON format.
         :return: metadata object of the prepared export
         :rtype: dict
 
@@ -1232,7 +1232,7 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
                 project = "Project Name",
                 folder_names = ["Folder 1", "Folder 2"],
                 annotation_statuses = ["Completed","QualityCheck"],
-                export_type = "CSV"
+                format = "CSV"
             )
 
             client.download_export("Project Name", export, "path_to_download")
@@ -2318,7 +2318,7 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
 
     def get_annotations(
         self,
-        project: Union[int, NotEmptyStr],
+        project: Union[NotEmptyStr, int],
         items: Optional[Union[List[NotEmptyStr], List[int]]] = None,
     ):
         """Returns annotations for the given list of items.
@@ -2663,29 +2663,28 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
 
     def list_items(
         self,
-        project: Union[int, str],
-        folder: Optional[Union[int, str]] = None,
+        project: Union[NotEmptyStr, int],
+        folder: Optional[Union[NotEmptyStr, int]] = None,
         *,
-        include: List[Literal["assignments", "custom_metadata"]] = None,
+        include: List[Literal["custom_metadata"]] = None,
         **filters,
     ):
         """
         Search items by filtering criteria.
 
-        :param project: The project name, project ID, or folder path (e.g., "project1/folder1") to search within.
+        :param project: The project name, project ID, or folder path (e.g., "project1") to search within.
                         This can refer to the root of the project or a specific subfolder.
-        :type project: Union[int, str]
+        :type project: Union[NotEmptyStr, int]
 
         :param folder: The folder name or ID to search within. If None, the search will be done in the root folder of
                        the project. If both “project” and “folder” specify folders, the “project”
                        value will take priority.
-        :type folder: Union[int, str], optional
+        :type folder: Union[NotEmptyStr, int], optional
 
         :param include: Specifies additional fields to include in the response.
 
                 Possible values are
 
-                - "assignee": Includes information about the role of the item assignee.
                 - "custom_metadata": Includes custom metadata attached to the item.
         :type include: list of str, optional
 
@@ -2695,8 +2694,8 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
 
 
                 Supported operations:
-                    - __ne: Value is in the list.
-                    - __in: Value is not equal.
+                    - __ne: Value is not equal.
+                    - __in: Value is in the list.
                     - __notin: Value is not in the list.
                     - __contains: Value has the substring.
                     - __starts: Value starts with the prefix.
@@ -2711,6 +2710,9 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
                 - name__contains: str
                 - name__starts: str
                 - name__ends: str
+                - annotation_status: str
+                - annotation_status__in: list[str]
+                - annotation_status__ne: list[str]
                 - approval_status: Literal["Approved", "Disapproved", None]
                 - assignments__user_id: str
                 - assignments__user_id__ne: str
@@ -2801,8 +2803,6 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
         if include:
             if "custom_metadata" not in include:
                 exclude.add("custom_metadata")
-            if "assignments" not in include:
-                exclude.add("assignments")
         return BaseSerializer.serialize_iterable(res, exclude=exclude)
 
     def attach_items(
@@ -2930,26 +2930,46 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
         source: Union[NotEmptyStr, dict],
         destination: Union[NotEmptyStr, dict],
         items: Optional[List[NotEmptyStr]] = None,
-        include_annotations: Optional[bool] = True,
+        include_annotations: bool = True,
+        duplicate_strategy: Literal[
+            "skip", "replace", "replace_annotations_only"
+        ] = "skip",
     ):
         """Copy images in bulk between folders in a project
 
-        :param source: project name or folder path to select items from (e.g., “project1/folder1”).
+        :param source: project name (root) or folder path to pick items from (e.g., “project1/folder1”).
         :type source: str
 
-        :param destination: project name (root) or folder path to place copied items.
+        :param destination: project name (root) or folder path to place copied items (e.g., “project1/folder2”).
         :type destination: str
 
         :param items: names of items to copy. If None, all items from the source directory will be copied.
         :type items: list of str
 
-        :param include_annotations: enables annotations copy
+        :param include_annotations: enables the copying of item data, including annotations, status, priority score,
+         approval state, and category. If set to False, only the items will be copied without additional data.
         :type include_annotations: bool
 
+        :param duplicate_strategy: Specifies the strategy for handling duplicate items in the destination.
+         The default value is "skip".
+
+            - "skip": skips duplicate items in the destination and continues with the next item.
+            - "replace": replaces the annotations, status, priority score, approval state, and category of duplicate items.
+            - "replace_annotations_only": replaces only the annotations of duplicate items,
+              leaving other data (status, priority score, approval state, and category) unchanged.
+
+        :type duplicate_strategy: Literal["skip", "replace", "replace_annotations_only"]
+
         :return: list of skipped item names
         :rtype: list of strs
         """
 
+        if not include_annotations and duplicate_strategy != "skip":
+            duplicate_strategy = "skip"
+            logger.warning(
+                "Copy operation continuing without annotations and metadata due to include_annotations=False."
+            )
+
         project_name, source_folder = extract_project_folder(source)
         to_project_name, destination_folder = extract_project_folder(destination)
         if project_name != to_project_name:
@@ -2963,6 +2983,7 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
             to_folder=to_folder,
             item_names=items,
             include_annotations=include_annotations,
+            duplicate_strategy=duplicate_strategy,
         )
         if response.errors:
             raise AppException(response.errors)
@@ -2974,18 +2995,31 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
         source: Union[NotEmptyStr, dict],
         destination: Union[NotEmptyStr, dict],
         items: Optional[List[NotEmptyStr]] = None,
+        duplicate_strategy: Literal[
+            "skip", "replace", "replace_annotations_only"
+        ] = "skip",
     ):
         """Move images in bulk between folders in a project
 
-        :param source: project name or folder path to pick items from (e.g., “project1/folder1”).
+        :param source: project name (root) or folder path to pick items from (e.g., “project1/folder1”).
         :type source: str
 
-        :param destination: project name (root) or folder path to move items to.
+        :param destination: project name (root) or folder path to move items to (e.g., “project1/folder2”).
         :type destination: str
 
         :param items: names of items to move. If None, all items from the source directory will be moved.
         :type items: list of str
 
+        :param duplicate_strategy: Specifies the strategy for handling duplicate items in the destination.
+         The default value is "skip".
+
+            - "skip": skips duplicate items in the destination and continues with the next item.
+            - "replace": replaces the annotations, status, priority score, approval state, and category of duplicate items.
+            - "replace_annotations_only": replaces only the annotations of duplicate items,
+              leaving other data (status, priority score, approval state, and category) unchanged.
+
+        :type duplicate_strategy: Literal["skip", "replace", "replace_annotations_only"]
+
         :return: list of skipped item names
         :rtype: list of strs
         """
@@ -3003,6 +3037,7 @@ class SAClient(BaseInterfaceFacade, metaclass=TrackableMeta):
             from_folder=source_folder,
             to_folder=destination_folder,
             item_names=items,
+            duplicate_strategy=duplicate_strategy,
         )
         if response.errors:
             raise AppException(response.errors)

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/core/entities/project.py

@@ -163,6 +163,7 @@ class TeamEntity(BaseModel):
     users: Optional[List[UserEntity]]
     pending_invitations: Optional[List[Any]]
     creator_id: Optional[str]
+    owner_id: Optional[str]
 
     class Config:
         extra = Extra.ignore

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/core/enums.py

@@ -108,7 +108,7 @@ class ProjectType(BaseTitledEnum):
     TILED = "Tiled", 5
     OTHER = "Other", 6
     POINT_CLOUD = "PointCloud", 7
-    GEN_AI = "GenAI", 8
+    MULTIMODAL = "Multimodal", 8
     UNSUPPORTED_TYPE_1 = "UnsupportedType", 9
     UNSUPPORTED_TYPE_2 = "UnsupportedType", 10
 

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/core/service_types.py

@@ -222,6 +222,10 @@ class ProjectResponse(ServiceResponse):
     res_data: entities.ProjectEntity = None
 
 
+class WorkflowResponse(ServiceResponse):
+    res_data: entities.WorkflowEntity = None
+
+
 class WorkflowListResponse(ServiceResponse):
     res_data: List[entities.WorkflowEntity] = None
 
@@ -242,5 +246,5 @@ PROJECT_TYPE_RESPONSE_MAP = {
     ProjectType.PIXEL: ImageResponse,
     ProjectType.DOCUMENT: DocumentResponse,
     ProjectType.POINT_CLOUD: PointCloudResponse,
-    ProjectType.GEN_AI: ImageResponse,
+    ProjectType.MULTIMODAL: ImageResponse,
 }

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/core/serviceproviders.py

@@ -5,6 +5,7 @@ from typing import Any
 from typing import Callable
 from typing import Dict
 from typing import List
+from typing import Literal
 
 from lib.core import entities
 from lib.core.conditions import Condition
@@ -70,6 +71,10 @@ class SuperannotateServiceProvider(ABC):
 
 
 class BaseWorkManagementService(SuperannotateServiceProvider):
+    @abstractmethod
+    def get_workflow(self, pk: int) -> entities.WorkflowEntity:
+        raise NotImplementedError
+
     @abstractmethod
     def list_workflows(self, query: Query) -> WorkflowListResponse:
         raise NotImplementedError
@@ -283,10 +288,30 @@ class BaseItemService(SuperannotateServiceProvider):
     ) -> ServiceResponse:
         raise NotImplementedError
 
+    @abstractmethod
+    def copy_move_multiple(
+        self,
+        project: entities.ProjectEntity,
+        from_folder: entities.FolderEntity,
+        to_folder: entities.FolderEntity,
+        item_names: List[str],
+        duplicate_strategy: Literal["skip", "replace", "replace_annotations_only"],
+        operation: Literal["copy", "move"],
+        include_annotations: bool = True,
+        include_pin: bool = False,
+    ) -> ServiceResponse:
+        raise NotImplementedError
+
     @abstractmethod
     def await_copy(self, project: entities.ProjectEntity, poll_id: int, items_count):
         raise NotImplementedError
 
+    @abstractmethod
+    def await_copy_move(
+        self, project: entities.ProjectEntity, poll_id: int, items_count
+    ):
+        raise NotImplementedError
+
     @abstractmethod
     def set_statuses(
         self,

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/core/usecases/annotations.py

@@ -36,7 +36,6 @@ from lib.core.entities import FolderEntity
 from lib.core.entities import ImageEntity
 from lib.core.entities import ProjectEntity
 from lib.core.entities import UserEntity
-from lib.core.entities import WorkflowEntity
 from lib.core.exceptions import AppException
 from lib.core.jsx_conditions import EmptyQuery
 from lib.core.jsx_conditions import Filter
@@ -477,13 +476,8 @@ class UploadAnnotationsUseCase(BaseReportableUseCase):
                 {i.item.name for i in items_to_upload}
                 - set(self._report.failed_annotations).union(set(skipped))
             )
-            response = self._service_provider.work_management.list_workflows(
-                Filter("id", self._project.workflow_id, OperatorEnum.EQ)
-            )
-            if not response.ok:
-                raise AppException(response.error)
-            workflow: WorkflowEntity = next(
-                (i for i in response.data if i.id == self._project.workflow_id), None
+            workflow = self._service_provider.work_management.get_workflow(
+                self._project.workflow_id
             )
             if workflow.is_system():
                 if uploaded_annotations and not self._keep_status:
@@ -842,13 +836,10 @@ class UploadAnnotationsFromFolderUseCase(BaseReportableUseCase):
             name_path_mappings.keys()
             - set(self._report.failed_annotations).union(set(missing_annotations))
         )
-        response = self._service_provider.work_management.list_workflows(
-            Filter("id", self._project.id, OperatorEnum.EQ)
+        workflow = self._service_provider.work_management.get_workflow(
+            self._project.workflow_id
         )
-        if response.error:
-            raise response.error
-        workflow = response.data[0]
-        if workflow.is_system and uploaded_annotations and not self._keep_status:
+        if workflow.is_system() and uploaded_annotations and not self._keep_status:
             statuses_changed = set_annotation_statuses_in_progress(
                 service_provider=self._service_provider,
                 project=self._project,
@@ -1084,13 +1075,10 @@ class UploadAnnotationUseCase(BaseReportableUseCase):
                                 ],
                                 Body=mask,
                             )
-                    response = self._service_provider.work_management.list_workflows(
-                        Filter("id", self._project.workflow_id, OperatorEnum.EQ)
+                    workflow = self._service_provider.work_management.get_workflow(
+                        self._project.workflow_id
                     )
-                    if not response.ok:
-                        raise AppException(response.error)
-                    workflow = response.data[0]
-                    if workflow.is_system and not self._keep_status:
+                    if workflow.is_system() and not self._keep_status:
                         statuses_changed = set_annotation_statuses_in_progress(
                             service_provider=self._service_provider,
                             project=self._project,
@@ -1426,11 +1414,8 @@ class ValidateAnnotationUseCase(BaseReportableUseCase):
             schema_response = self._service_provider.annotations.get_schema(
                 self._project_type, version
             )
-            if not schema_response.ok:
+            if not schema_response.ok or not schema_response.data:
                 raise AppException(f"Schema {version} does not exist.")
-            if not schema_response.data:
-                ValidateAnnotationUseCase.SCHEMAS[key] = lambda x: x
-                return ValidateAnnotationUseCase.SCHEMAS[key]
             validator = superannotate_schemas.Draft7Validator(schema_response.data)
             from functools import partial
 

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/core/usecases/images.py

@@ -743,19 +743,15 @@ class UploadImageToProject(BaseUseCase):
         self._s3_repo = s3_repo
         self._service_provider = service_provider
         if annotation_status_value is None:
-            response = self._service_provider.work_management.list_workflows(
-                Filter("id", self._project.workflow_id, OperatorEnum.EQ)
+            workflow = self._service_provider.work_management.get_workflow(
+                self._project.workflow_id
             )
-            if response.error:
-                raise AppException(response.error)
-            workflow = response.data[0]
-            if workflow.is_system:
+            if workflow.is_system():
                 annotation_status_value = (
                     self._service_provider.get_annotation_status_value(
                         self._project, "NotStarted"
                     )
                 )
-
         self._annotation_status_value = annotation_status_value
         self._auth_data = None
 
@@ -1106,13 +1102,10 @@ class UploadImagesToProject(BaseInteractiveUseCase):
             attach_duplications_list = []
 
             if not self._annotation_status_value:
-                response = self._service_provider.work_management.list_workflows(
-                    Filter("id", self._project.workflow_id, OperatorEnum.EQ)
+                workflow = self._service_provider.work_management.get_workflow(
+                    self._project.workflow_id
                 )
-                if response.error:
-                    raise AppException(response.error)
-                workflow = response.data[0]
-                if workflow.is_system:
+                if workflow.is_system():
                     self._annotation_status_value = (
                         self._service_provider.get_annotation_status_value(
                             self._project, "NotStarted"

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/core/usecases/items.py

@@ -33,6 +33,7 @@ from lib.core.usecases.base import BaseUseCase
 from lib.core.usecases.folders import SearchFoldersUseCase
 from lib.infrastructure.utils import divide_to_chunks
 from lib.infrastructure.utils import extract_project_folder
+from typing_extensions import Literal
 
 logger = logging.getLogger("sa")
 
@@ -537,6 +538,154 @@ class MoveItems(BaseReportableUseCase):
         return self._response
 
 
+class CopyMoveItems(BaseReportableUseCase):
+    """
+    Copy/Move items in bulk between folders in a project.
+    Return skipped item names.
+    """
+
+    def __init__(
+        self,
+        reporter: Reporter,
+        project: ProjectEntity,
+        from_folder: FolderEntity,
+        to_folder: FolderEntity,
+        item_names: List[str],
+        service_provider: BaseServiceProvider,
+        include_annotations: bool,
+        duplicate_strategy: Literal["skip", "replace", "replace_annotations_only"],
+        operation: Literal["copy", "move"],
+        chunk_size: int = 1000,
+    ):
+        super().__init__(reporter)
+        self._project = project
+        self._from_folder = from_folder
+        self._to_folder = to_folder
+        self._item_names = item_names
+        self._service_provider = service_provider
+        self._include_annotations = include_annotations
+        self._duplicate_strategy = duplicate_strategy
+        self._operation = operation
+        self._chunk_size = chunk_size
+
+    def _validate_limitations(self, items_count):
+        response = self._service_provider.get_limitations(
+            project=self._project,
+            folder=self._to_folder,
+        )
+        if not response.ok:
+            raise AppValidationException(response.error)
+        if self._operation == "copy":
+            folder_limit_err_msg = constants.COPY_FOLDER_LIMIT_ERROR_MESSAGE
+            project_limit_err_msg = constants.COPY_PROJECT_LIMIT_ERROR_MESSAGE
+        else:
+            folder_limit_err_msg = constants.MOVE_FOLDER_LIMIT_ERROR_MESSAGE
+            project_limit_err_msg = constants.MOVE_PROJECT_LIMIT_ERROR_MESSAGE
+        if items_count > response.data.folder_limit.remaining_image_count:
+            raise AppValidationException(folder_limit_err_msg)
+        if items_count > response.data.project_limit.remaining_image_count:
+            raise AppValidationException(project_limit_err_msg)
+
+    def validate_item_names(self):
+        if self._item_names:
+            self._item_names = list(set(self._item_names))
+
+    def execute(self):
+        if self.is_valid():
+            if self._item_names:
+                items = self._item_names
+            else:
+                res = self._service_provider.item_service.list(
+                    self._project.id, self._from_folder.id, EmptyQuery()
+                )
+                if res.error:
+                    raise AppException(res.error)
+                items = [i.name for i in res.data]
+            try:
+                self._validate_limitations(len(items))
+            except AppValidationException as e:
+                self._response.errors = e
+                return self._response
+            skipped_items = []
+            if self._duplicate_strategy == "skip":
+                existing_items = []
+                for i in range(0, len(items), self._chunk_size):
+                    query = Filter(
+                        "name", items[i : i + self._chunk_size], OperatorEnum.IN
+                    )  # noqa
+                    res = self._service_provider.item_service.list(
+                        self._project.id, self._to_folder.id, query
+                    )
+                    if res.error:
+                        raise AppException(res.error)
+                    if not res.data:
+                        continue
+                    existing_items += res.data
+                duplications = [item.name for item in existing_items]
+                items_to_processing = list(set(items) - set(duplications))
+                skipped_items.extend(duplications)
+            else:
+                items_to_processing = items
+            if items_to_processing:
+                for i in range(0, len(items_to_processing), self._chunk_size):
+                    chunk_to_process = items_to_processing[
+                        i : i + self._chunk_size
+                    ]  # noqa: E203
+                    response = self._service_provider.items.copy_move_multiple(
+                        project=self._project,
+                        from_folder=self._from_folder,
+                        to_folder=self._to_folder,
+                        item_names=chunk_to_process,
+                        include_annotations=self._include_annotations,
+                        duplicate_strategy=self._duplicate_strategy,
+                        operation=self._operation,
+                    )
+                    if not response.ok or not response.data.get("poll_id"):
+                        skipped_items.extend(chunk_to_process)
+                        continue
+                    try:
+                        self._service_provider.items.await_copy_move(
+                            project=self._project,
+                            poll_id=response.data["poll_id"],
+                            items_count=len(chunk_to_process),
+                        )
+                    except BackendError as e:
+                        self._response.errors = AppException(e)
+                        return self._response
+                existing_items = []
+                for i in range(0, len(items_to_processing), self._chunk_size):
+                    res = self._service_provider.item_service.list(
+                        self._project.id,
+                        self._to_folder.id,
+                        Filter(
+                            "name",
+                            items_to_processing[i : i + self._chunk_size],
+                            OperatorEnum.IN,
+                        ),  # noqa
+                    )
+                    if res.error:
+                        raise AppException(res.error)
+
+                    existing_items += res.data
+
+                existing_item_names_set = {item.name for item in existing_items}
+                items_to_processing_names_set = set(items_to_processing)
+                processed_items = existing_item_names_set.intersection(
+                    items_to_processing_names_set
+                )
+                skipped_items.extend(
+                    list(items_to_processing_names_set - processed_items)
+                )
+                operation_processing_map = {"copy": "Copied", "move": "Moved"}
+                self.reporter.log_info(
+                    f"{operation_processing_map[self._operation]} {len(processed_items)}/{len(items_to_processing)} item(s) from "
+                    f"{self._project.name}{'' if self._from_folder.is_root else f'/{self._from_folder.name}'} to "
+                    f"{self._project.name}{'' if self._to_folder.is_root else f'/{self._to_folder.name}'}"
+                )
+            self._response.data = list(set(skipped_items))
+        return self._response
+
+
 class SetAnnotationStatues(BaseReportableUseCase):
     CHUNK_SIZE = 500
     ERROR_MESSAGE = "Failed to change status"
@@ -926,7 +1075,6 @@ class AddItemsToSubsetUseCase(BaseUseCase):
         self,
     ):
         if self.is_valid():
-
             futures = []
             with ThreadPoolExecutor(max_workers=4) as executor:
                 for path, items in self.path_separated.items():

{superannotate-4.4.25.dev2 → superannotate-4.4.26.dev1}/src/superannotate/lib/core/usecases/models.py

@@ -82,7 +82,10 @@ class PrepareExportUseCase(BaseUseCase):
                 raise AppValidationException(
                     "COCO format is not supported for this project."
                 )
-        elif self._export_type == 3 and self._project.type != ProjectType.GEN_AI.value:
+        elif (
+            self._export_type == 3
+            and self._project.type != ProjectType.MULTIMODAL.value
+        ):
             raise AppValidationException(
                 "CSV format is not supported for this project."
             )