updated query, get_subsets

Author: VaghinakDev

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

@@ -2435,12 +2435,22 @@ def query(
         :rtype: list of dicts
         """
         project_name, folder_name = extract_project_folder(project)
-        response = self.controller.query_entities(
-            project_name, folder_name, query, subset
-        )
-        if response.errors:
-            raise AppException(response.errors)
-        return BaseSerializer.serialize_iterable(response.data, exclude={"meta"})
+        project = self.controller.get_project(project_name)
+        subset_id = None
+        if subset:
+            subset = next(
+                (i for i in project.list_subsets() if i["name"] == subset), None
+            )
+            if not subset:
+                raise AppException("Subset not found")
+            subset_id = subset["id"]
+        if folder_name:
+            folder = project.get_folder(folder_name)
+            _items = folder.list_items(query=query, subset_id=subset_id)
+        else:
+            _items = project.list_items(query=query, subset_id=subset_id)
+        exclude = {"custom_metadata", "meta"}
+        return [serialize_item(i, project).dict(exclude=exclude) for i in _items]
 
     def get_item_metadata(
         self,
@@ -3213,6 +3223,8 @@ def delete_custom_values(
     def add_items_to_subset(
         self, project: NotEmptyStr, subset: NotEmptyStr, items: List[dict]
     ):
+
+        # todo we can update the interface because there has been no usage since may 26
         """
 
         Associates selected items with a given subset. Non-existing subset will be automatically created.
@@ -3286,12 +3298,10 @@ def add_items_to_subset(
         """
 
         project_name, _ = extract_project_folder(project)
-        project = self.controller.projects.get_by_name(project_name).data
-        response = self.controller.subsets.add_items(project, subset, items)
-        if response.errors:
-            raise AppException(response.errors)
+        project = self.controller.get_project(project_name)
+        successed, skipped, failed = project.add_items_to_subset(subset, items)
 
-        return response.data
+        return {"successed": successed, "skipped": skipped, "failed": failed}
 
     def set_approval_statuses(
         self,

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

@@ -6,7 +6,6 @@
 from concurrent.futures import ThreadPoolExecutor
 from typing import Dict
 from typing import List
-from typing import Optional
 
 import superannotate.lib.core as constants
 from lib.core.conditions import Condition
@@ -17,7 +16,6 @@
 from lib.core.entities import FolderEntity
 from lib.core.entities import ImageEntity
 from lib.core.entities import ProjectEntity
-from lib.core.entities import SubSetEntity
 from lib.core.entities import VideoEntity
 from lib.core.exceptions import AppException
 from lib.core.exceptions import AppValidationException
@@ -34,31 +32,6 @@
 logger = logging.getLogger("sa")
 
 
-class GetItemByIDUseCase(BaseUseCase):
-    def __init__(self, item_id, project, service_provider):
-        self._item_id = item_id
-        self._project = project
-        self._service_provider = service_provider
-        super().__init__()
-
-    def execute(
-        self,
-    ):
-        try:
-            response = self._service_provider.items.get_by_id(
-                item_id=self._item_id,
-                project_id=self._project.id,
-                project_type=self._project.type,
-            )
-            if not response.ok:
-                self._response.errors = response.error
-        except AppException as e:
-            self._response.errors = e
-        else:
-            self._response.data = response.data
-        return self._response
-
-
 class GetItem(BaseReportableUseCase):
     def __init__(
         self,
@@ -124,94 +97,6 @@ def execute(self) -> Response:
         return self._response
 
 
-class QueryEntitiesUseCase(BaseReportableUseCase):
-    def __init__(
-        self,
-        reporter: Reporter,
-        project: ProjectEntity,
-        folder: FolderEntity,
-        service_provider: BaseServiceProvider,
-        query: str,
-        subset: str = None,
-    ):
-        super().__init__(reporter)
-        self._project = project
-        self._folder = folder
-        self._service_provider = service_provider
-        self._query = query
-        self._subset = subset
-
-    def validate_arguments(self):
-        if self._query:
-            response = self._service_provider.validate_saqul_query(
-                project=self._project, query=self._query
-            )
-
-            if not response.ok:
-                raise AppException(response.error)
-            if response.data["isValidQuery"]:
-                self._query = response.data["parsedQuery"]
-            else:
-                raise AppException("Incorrect query.")
-        else:
-            response = self._service_provider.validate_saqul_query(self._project, "-")
-            if not response.ok:
-                raise AppException(response.error)
-
-        if not any([self._query, self._subset]):
-            raise AppException(
-                "The query and subset params cannot have the value None at the same time."
-            )
-        if self._subset and not self._folder.is_root:
-            raise AppException(
-                "The folder name should be specified in the query string."
-            )
-
-    def execute(self) -> Response:
-        if self.is_valid():
-            query_kwargs = {}
-            if self._subset:
-                subset: Optional[SubSetEntity] = None
-                response = self._service_provider.subsets.list(self._project)
-                if response.ok:
-                    subset = next(
-                        (_sub for _sub in response.data if _sub.name == self._subset),
-                        None,
-                    )
-                else:
-                    self._response.errors = response.error
-                    return self._response
-                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"] = (
-                None if self._folder.name == "root" else self._folder
-            )
-            service_response = self._service_provider.saqul_query(
-                self._project,
-                **query_kwargs,
-            )
-            if service_response.ok:
-                data = []
-                for i, item in enumerate(service_response.data):
-                    tmp_item = GetItem.serialize_entity(
-                        BaseItemEntity(**item), self._project
-                    )
-                    folder_path = f"{'/' + item['folder_name'] if not item['is_root_folder'] else ''}"
-                    tmp_item.path = f"{self._project.name}" + folder_path
-                    data.append(tmp_item)
-                self._response.data = data
-            else:
-                self._response.errors = service_response.data
-        return self._response
-
-
 class ListItems(BaseUseCase):
     def __init__(
         self,

src/superannotate/lib/infrastructure/controller.py

@@ -306,14 +306,6 @@ def get_by_name(
         )
         return use_case.execute()
 
-    def get_by_id(self, item_id: int, project: ProjectEntity):
-        use_case = usecases.GetItemByIDUseCase(
-            item_id=item_id,
-            project=project,
-            service_provider=self.service_provider,
-        )
-        return use_case.execute()
-
     def list(
         self,
         project: ProjectEntity,
@@ -1167,19 +1159,3 @@ def get_annotations_per_frame(
             service_provider=self.service_provider,
         )
         return use_case.execute()
-
-    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.QueryEntitiesUseCase(
-            reporter=self.get_default_reporter(),
-            project=project,
-            folder=folder,
-            query=query,
-            subset=subset,
-            service_provider=self.service_provider,
-        )
-        return use_case.execute()

src/superannotate/lib/infrastructure/services/subset.py

@@ -30,7 +30,7 @@ def create_multiple(self, project: entities.ProjectEntity, name: List[str]):
     def add_items(
         self,
         project: entities.ProjectEntity,
-        subset: entities.SubSetEntity,
+        lis: entities.SubSetEntity,
         item_ids: List[int],
     ):
         data = {"action": "ATTACH", "item_ids": item_ids}

tests/integration/base.py

@@ -29,6 +29,7 @@ def tearDown(self) -> None:
                 try:
                     sa.delete_project(project)
                 except Exception:
+                    raise
                     pass
         except Exception as e:
             raise e

tests/integration/items/test_saqul_query.py

@@ -52,7 +52,7 @@ def test_query(self):
         except Exception as e:
             self.assertEqual(
                 str(e),
-                "Subset not found. Use the superannotate.get_subsets() function to get a list of the available subsets.",
+                "Subset not found.",  # todo removed "Use the superannotate.get_subsets() function to get a list of the available subsets.",
             )
 
     def test_query_on_100(self):

tests/integration/subsets/test_subsets.py

@@ -15,13 +15,12 @@ def test_add_items_to_subset(self):
             {"name": f"earth_mov_00{i}.jpg", "url": f"url_{i}"} for i in range(1, 6)
         ]
         sa.attach_items(self.PROJECT_NAME, item_names)  # noqa
-        subset_data = []
-        for i in item_names:
-            subset_data.append({"name": i["name"], "path": self.PROJECT_NAME})
-        result = sa.add_items_to_subset(
-            self.PROJECT_NAME, self.SUBSET_NAME, subset_data
-        )
-        assert len(subset_data) == len(result["succeeded"])
+        items = sa.search_items(self.PROJECT_NAME)
+        # subset_data = []
+        # for i in item_names:
+        #     subset_data.append({"name": i["name"], "path": self.PROJECT_NAME})
+        result = sa.add_items_to_subset(self.PROJECT_NAME, self.SUBSET_NAME, items)
+        assert len(result["succeeded"]) == 5
 
     def test_add_to_subset_with_duplicates_items(self):
         with self.assertLogs("sa", level="INFO") as cm: