changed download_image_annotations to sdk_core

Author: nareksa

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

@@ -1097,12 +1097,15 @@ def download_image_annotations(
         :rtype: tuple
         """
 
-        project, folder = self.controller.get_project_folder_by_path(project)
+        project_name, folder_name = extract_project_folder(project)
+        project = self.controller.get_project(project_name)
+        folder = project.get_folder(folder_name)
+        download_path = self.controller.setup_destination_dir(local_dir_path)
         res = self.controller.annotations.download_image_annotations(
             project=project,
             folder=folder,
             image_name=image_name,
-            destination=local_dir_path,
+            destination=download_path,
         )
         if res.errors:
             raise AppException(res.errors)

src/superannotate/lib/core/serviceproviders.py

@@ -479,8 +479,8 @@ def get_limitations(
     @abstractmethod
     def get_download_token(
         self,
-        project: entities.ProjectEntity,
-        folder: entities.FolderEntity,
+        project_id: int,
+        folder_id: int,
         image_id: int,
         include_original: int = 1,
     ) -> ServiceResponse:

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

@@ -46,6 +46,9 @@
 from lib.core.usecases.base import BaseReportableUseCase
 from lib.core.usecases.base import BaseUseCase
 from PIL import UnidentifiedImageError
+from superannotate_core.app import Folder
+from superannotate_core.app import Item
+from superannotate_core.app import Project
 
 logger = logging.getLogger("sa")
 
@@ -1381,8 +1384,8 @@ def execute(self) -> Response:
 class DownloadImageAnnotationsUseCase(BaseUseCase):
     def __init__(
         self,
-        project: ProjectEntity,
-        folder: FolderEntity,
+        project: Project,
+        folder: Folder,
         image_name: str,
         service_provider: BaseServiceProvider,
         destination: str,
@@ -1394,15 +1397,6 @@ def __init__(
         self._service_provider = service_provider
         self._destination = destination
 
-    @property
-    def image_use_case(self):
-        return GetImageUseCase(
-            service_provider=self._service_provider,
-            project=self._project,
-            folder=self._folder,
-            image_name=self._image_name,
-        )
-
     def validate_project_type(self):
         if self._project.type in constances.LIMITED_FUNCTIONS:
             raise AppValidationException(
@@ -1476,56 +1470,32 @@ def fill_classes_data(self, annotations: dict):
 
     def execute(self):
         if self.is_valid():
-            data = {
-                "annotation_json": None,
-                "annotation_json_filename": None,
-                "annotation_mask": None,
-                "annotation_mask_filename": None,
-            }
-            image_response = self.image_use_case.execute()
-            token = self._service_provider.get_download_token(
-                project=self._project,
-                folder=self._folder,
-                image_id=image_response.data.id,
-            ).data
-            credentials = token["annotations"]["MAIN"][0]
-
-            annotation_json_creds = credentials["annotation_json_path"]
-
-            response = requests.get(
-                url=annotation_json_creds["url"],
-                headers=annotation_json_creds["headers"],
-            )
-            if not response.ok:
-                # TODO remove
-                logger.warning("Couldn't load annotations.")
-                self._response.data = (None, None)
-                return self._response
-            data["annotation_json"] = response.json()
-            data["annotation_json_filename"] = f"{self._image_name}.json"
             mask_path = None
-            if self._project.type == constances.ProjectType.PIXEL.value:
-                annotation_blue_map_creds = credentials["annotation_bluemap_path"]
+            if self._project.type.value == constances.ProjectType.PIXEL.value:
+                image: Item = self._folder.list_items(item_names=[self._image_name])[0]
+                token = self._service_provider.get_download_token(
+                    project_id=self._project.id,
+                    folder_id=self._folder.id,
+                    image_id=image.id,
+                ).data
+                annotation_blue_map_creds = token["annotations"]["MAIN"][0][
+                    "annotation_bluemap_path"
+                ]
                 response = requests.get(
                     url=annotation_blue_map_creds["url"],
                     headers=annotation_blue_map_creds["headers"],
                 )
-                data["annotation_mask_filename"] = f"{self._image_name}___save.png"
+                annotation_mask_filename = f"{self._image_name}___save.png"
                 if response.ok:
-                    data["annotation_mask"] = io.BytesIO(response.content).getbuffer()
-                    mask_path = (
-                        Path(self._destination) / data["annotation_mask_filename"]
-                    )
+                    mask_path = Path(self._destination) / annotation_mask_filename
                     with open(mask_path, "wb") as f:
-                        f.write(data["annotation_mask"])
+                        f.write(io.BytesIO(response.content).getbuffer())
                 else:
                     logger.info("There is no blue-map for the image.")
-
-            json_path = Path(self._destination) / data["annotation_json_filename"]
-            self.fill_classes_data(data["annotation_json"])
-            with open(json_path, "w") as f:
-                json.dump(data["annotation_json"], f, indent=4)
-
+            self._folder.download_annotations(
+                download_path=self._destination, item_names=[self._image_name]
+            )
+            json_path = f"{self._destination}/{self._image_name}"
             self._response.data = (str(json_path), str(mask_path))
         return self._response
 

src/superannotate/lib/infrastructure/controller.py

@@ -490,8 +490,8 @@ def download(
 
     def download_image_annotations(
         self,
-        project: ProjectEntity,
-        folder: FolderEntity,
+        project: Project,
+        folder: Folder,
         image_name: str,
         destination: str,
     ):

src/superannotate/lib/infrastructure/serviceprovider.py

@@ -79,8 +79,8 @@ def get_limitations(
 
     def get_download_token(
         self,
-        project: entities.ProjectEntity,
-        folder: entities.FolderEntity,
+        project_id: int,
+        folder_id: int,
         image_id: int,
         include_original: int = 1,
     ):
@@ -92,8 +92,8 @@ def get_download_token(
             download_token_url,
             "get",
             params={
-                "project_id": project.id,
-                "folder_id": folder.id,
+                "project_id": project_id,
+                "folder_id": folder_id,
                 "include_original": include_original,
             },
         )

tests/integration/annotations/test_download_annotations.py

@@ -121,6 +121,7 @@ def test_download_annotations_from_folders_mul(self):
             )
             assert count == 31 + 5  # folder names and classes
 
+    # TODO failed after SDK_core integration (check logging in future)
     def test_download_annotations_duplicated_names(self):
         self._attach_items(count=4)
         with tempfile.TemporaryDirectory() as temp_dir:

tests/integration/annotations/test_get_annotations.py

@@ -4,6 +4,7 @@
 from pathlib import Path
 
 import pytest
+from requests.exceptions import HTTPError
 from src.superannotate import SAClient
 from tests.integration.base import BaseTestCase
 
@@ -58,6 +59,7 @@ def test_get_annotations_by_ids(self):
 
         self.assertEqual(len(annotations), 4)
 
+    # TODO check the behavior of get_annotations in case of item_ids in the future
     def test_get_annotations_by_ids_with_duplicate_names(self):
         sa.create_folder(self.PROJECT_NAME, self.FOLDER_NAME_2)
         self._attach_items(count=4, folder=self.FOLDER_NAME_2)  # noqa
@@ -87,12 +89,9 @@ def test_get_annotations_by_wrong_item_ids(self):
 
         self.assertEqual(len(annotations), 0)
 
-    # todo update the implementation
+    # TODO update the implementation
     def test_get_annotations_by_wrong_project_ids(self):
-        try:
-            sa.get_annotations(1, [1, 2, 3])
-        except Exception as e:
-            self.assertEqual(str(e), "Project not found.")
+        self.assertRaises(HTTPError, sa.get_annotations, 1, [1, 2, 3])
 
     @pytest.mark.flaky(reruns=3)
     def test_get_annotations_order(self):
@@ -177,6 +176,7 @@ def test_get_annotations10000(self):
         a = sa.get_annotations(self.PROJECT_NAME)
         assert len(a) == count
 
+    # TODO failed after SDK_core integration (check logging in future)
     def test_get_annotations_logs(self):
         self._attach_items(count=4)
         items_names = [self.IMAGE_NAME] * 4

tests/integration/annotations/test_preannotation_upload.py

@@ -19,7 +19,7 @@ def folder_path(self):
         return os.path.join(Path(__file__).parent.parent.parent, self.TEST_FOLDER_PATH)
 
     def test_pre_annotation_folder_upload_download(self):
-        self._attach_items()
+        self._attach_items(count=4)
         sa.create_annotation_classes_from_classes_json(
             self.PROJECT_NAME, f"{self.folder_path}/classes/classes.json"
         )