Merge branch 'friday' into 1028_delete_items

Author: VaghinakDev

docs/source/superannotate.sdk.rst

@@ -73,11 +73,20 @@ ______
 .. automethod:: superannotate.SAClient.attach_items
 .. automethod:: superannotate.SAClient.copy_items
 .. automethod:: superannotate.SAClient.move_items
+.. automethod:: superannotate.SAClient.assign_items
+.. automethod:: superannotate.SAClient.unassign_items
 .. automethod:: superannotate.SAClient.get_item_metadata
 .. automethod:: superannotate.SAClient.set_annotation_statuses
 
 ----------
 
+Subsets
+______
+
+.. automethod:: superannotate.SAClient.get_subsets
+
+----------
+
 Images
 ______
 

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

@@ -2450,7 +2450,12 @@ def attach_items_from_integrated_storage(
         if response.errors:
             raise AppException(response.errors)
 
-    def query(self, project: NotEmptyStr, query: Optional[NotEmptyStr]):
+    def query(
+        self,
+        project: NotEmptyStr,
+        query: Optional[NotEmptyStr] = None,
+        subset: Optional[NotEmptyStr] = None,
+    ):
         """Return items that satisfy the given query.
         Query syntax should be in SuperAnnotate query language(https://doc.superannotate.com/docs/query-search-1).
 
@@ -2460,11 +2465,17 @@ def query(self, project: NotEmptyStr, query: Optional[NotEmptyStr]):
         :param query: SAQuL query string.
         :type query: str
 
+        :param subset:  subset name. Allows you to query items in a specific subset.
+        To return all the items in the specified subset, set the value of query param to None.
+        :type subset: str
+
         :return: queried items’ metadata list
         :rtype: list of dicts
         """
         project_name, folder_name = extract_project_folder(project)
-        response = self.controller.query_entities(project_name, folder_name, query)
+        response = self.controller.query_entities(
+            project_name, folder_name, query, subset
+        )
         if response.errors:
             raise AppException(response.errors)
         return BaseSerializer.serialize_iterable(response.data)
@@ -2771,3 +2782,19 @@ def download_annotations(
         if response.errors:
             raise AppException(response.errors)
         return response.data
+
+    def get_subsets(self, project: Union[NotEmptyStr, dict]):
+        """Get Subsets
+
+        :param project: project name (e.g., “project1”)
+        :type project: str
+
+        :return: subsets’ metadata
+        :rtype: list of dicts
+        """
+        project_name, _ = extract_project_folder(project)
+
+        response = self.controller.list_subsets(project_name)
+        if response.errors:
+            raise AppException(response.errors)
+        return BaseSerializer.serialize_iterable(response.data, ["name"])

src/superannotate/lib/core/entities/__init__.py

@@ -2,6 +2,7 @@
 from lib.core.entities.base import BaseEntity as TmpBaseEntity
 from lib.core.entities.base import ProjectEntity
 from lib.core.entities.base import SettingEntity
+from lib.core.entities.base import SubSetEntity
 from lib.core.entities.integrations import IntegrationEntity
 from lib.core.entities.items import DocumentEntity
 from lib.core.entities.items import Entity
@@ -31,6 +32,7 @@
 __all__ = [
     # base
     "SettingEntity",
+    "SubSetEntity",
     # items
     "TmpImageEntity",
     "BaseEntity",

src/superannotate/lib/core/entities/base.py

@@ -27,6 +27,14 @@ def validate(cls, v: datetime):
         return v.isoformat()
 
 
+class SubSetEntity(BaseModel):
+    id: Optional[int]
+    name: str
+
+    class Config:
+        extra = Extra.ignore
+
+
 class TimedBaseModel(BaseModel):
     createdAt: StringDate = Field(None, alias="createdAt")
     updatedAt: StringDate = Field(None, alias="updatedAt")

src/superannotate/lib/core/service_types.py

@@ -6,6 +6,7 @@
 
 from pydantic import BaseModel
 from pydantic import Extra
+from pydantic import parse_obj_as
 
 
 class Limit(BaseModel):
@@ -81,7 +82,7 @@ def __init__(self, response, content_type=None):
         }
         try:
             if content_type and content_type is not self.__class__:
-                data["data"] = content_type(**response.json())
+                data["data"] = parse_obj_as(content_type, response.json())
             else:
                 data["data"] = response.json()
         except Exception as e:

src/superannotate/lib/core/serviceproviders.py

@@ -365,9 +365,17 @@ def attach_integrations(
         raise NotImplementedError
 
     def saqul_query(
-        self, team_id: int, project_id: int, query: str, folder_id: int
+        self,
+        team_id: int,
+        project_id: int,
+        folder_id: int,
+        query: str = None,
+        subset_id: int = None,
     ) -> ServiceResponse:
         raise NotImplementedError
 
     def validate_saqul_query(self, team_id: int, project_id: int, query: str) -> dict:
         raise NotImplementedError
+
+    def list_sub_sets(self, team_id: int, project_id: int) -> ServiceResponse:
+        raise NotImplementedError

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

@@ -1,5 +1,6 @@
 import copy
 from typing import List
+from typing import Optional
 
 import superannotate.lib.core as constants
 from lib.core.conditions import Condition
@@ -9,6 +10,7 @@
 from lib.core.entities import Entity
 from lib.core.entities import FolderEntity
 from lib.core.entities import ProjectEntity
+from lib.core.entities import SubSetEntity
 from lib.core.entities import TmpImageEntity
 from lib.core.entities import VideoEntity
 from lib.core.exceptions import AppException
@@ -112,41 +114,78 @@ def execute(self) -> Response:
         return self._response
 
 
-class QueryEntities(BaseReportableUseCase):
+class QueryEntitiesUseCase(BaseReportableUseCase):
     def __init__(
         self,
         reporter: Reporter,
         project: ProjectEntity,
         folder: FolderEntity,
         backend_service_provider: SuperannotateServiceProvider,
         query: str,
+        subset: str,
     ):
         super().__init__(reporter)
         self._project = project
         self._folder = folder
         self._backend_client = backend_service_provider
         self._query = query
+        self._subset = subset
 
     def validate_query(self):
-        response = self._backend_client.validate_saqul_query(
-            self._project.team_id, self._project.id, self._query
-        )
-        if response.get("error"):
-            raise AppException(response["error"])
-        if response["isValidQuery"]:
-            self._query = response["parsedQuery"]
-        else:
-            raise AppException("Incorrect query.")
-        if self._project.sync_status != constants.ProjectState.SYNCED.value:
+        if self._project.sync_status != constances.ProjectState.SYNCED.value:
             raise AppException("Data is not synced.")
+        if self._query:
+            response = self._backend_client.validate_saqul_query(
+                self._project.team_id, self._project.id, self._query
+            )
+            if response.get("error"):
+                raise AppException(response["error"])
+            if response["isValidQuery"]:
+                self._query = response["parsedQuery"]
+            else:
+                raise AppException("Incorrect query.")
+        else:
+            response = self._backend_client.validate_saqul_query(
+                self._project.team_id, self._project.id, "-"
+            )
+            if response.get("error"):
+                raise AppException(response["error"])
 
     def execute(self) -> Response:
+        if not any([self._query, self._subset]):
+            self._response.errors = AppException(
+                "AppException: The query and subset params cannot have the value None at the same time."
+            )
+            return self._response
+
         if self.is_valid():
+            query_kwargs = {}
+            if self._subset:
+                subset: Optional[SubSetEntity] = None
+                response = self._backend_client.list_sub_sets(
+                    team_id=self._project.team_id, project_id=self._project.id
+                )
+                if response.ok:
+                    subset = next(
+                        (_sub for _sub in response.data if _sub.name == self._subset),
+                        None,
+                    )
+                if not subset:
+                    self._response.errors = AppException(
+                        "Subset not found. Use the superannotate."
+                        "get_subsets() function to get a list of the available subsets."
+                    )
+                    return self._response
+                query_kwargs["subset_id"] = subset.id
+            if self._query:
+                query_kwargs["query"] = self._query
+            query_kwargs["folder_id"] = (
+                None if self._folder.name == "root" else self._folder.uuid
+            )
             service_response = self._backend_client.saqul_query(
                 self._project.team_id,
                 self._project.id,
-                self._query,
-                folder_id=None if self._folder.name == "root" else self._folder.uuid,
+                **query_kwargs,
             )
             if service_response.ok:
                 data = []

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

@@ -19,6 +19,7 @@
 from lib.core.reporter import Reporter
 from lib.core.repositories import BaseManageableRepository
 from lib.core.repositories import BaseReadOnlyRepository
+from lib.core.response import Response
 from lib.core.serviceproviders import SuperannotateServiceProvider
 from lib.core.usecases.base import BaseReportableUseCase
 from lib.core.usecases.base import BaseUseCase
@@ -1079,3 +1080,38 @@ def execute(self):
                     )
             self._response.data = invited, list(to_skip)
             return self._response
+
+
+class ListSubsetsUseCase(BaseReportableUseCase):
+    def __init__(
+        self,
+        reporter: Reporter,
+        project: ProjectEntity,
+        backend_client: SuperannotateServiceProvider,
+    ):
+        super().__init__(reporter)
+        self._project = project
+        self._backend_client = backend_client
+
+    def validate_project(self):
+        if self._project.sync_status != constances.ProjectState.SYNCED.value:
+            raise AppException("Data is not synced.")
+
+        response = self._backend_client.validate_saqul_query(
+            self._project.team_id, self._project.id, "_"
+        )
+        error = response.get("error")
+        if error:
+            raise AppException(response["error"])
+
+    def execute(self) -> Response:
+        if self.is_valid():
+            sub_sets_response = self._backend_client.list_sub_sets(
+                team_id=self._project.team_id, project_id=self._project.id
+            )
+            if sub_sets_response.ok:
+                self._response.data = sub_sets_response.data
+            else:
+                self._response.data = []
+
+        return self._response

src/superannotate/lib/infrastructure/controller.py

@@ -1527,15 +1527,18 @@ def attach_integrations(
         )
         return use_case.execute()
 
-    def query_entities(self, project_name: str, folder_name: str, query: str = None):
+    def query_entities(
+        self, project_name: str, folder_name: str, query: str = None, subset: str = None
+    ):
         project = self._get_project(project_name)
         folder = self._get_folder(project, folder_name)
 
-        use_case = usecases.QueryEntities(
+        use_case = usecases.QueryEntitiesUseCase(
             reporter=self.get_default_reporter(),
             project=project,
             folder=folder,
             query=query,
+            subset=subset,
             backend_service_provider=self.backend_client,
         )
         return use_case.execute()
@@ -1707,3 +1710,12 @@ def download_annotations(
             callback=callback,
         )
         return use_case.execute()
+
+    def list_subsets(self, project_name: str):
+        project = self._get_project(project_name)
+        use_case = usecases.ListSubsetsUseCase(
+            reporter=self.get_default_reporter(),
+            project=project,
+            backend_client=self.backend_client,
+        )
+        return use_case.execute()