refactor upload_priority_scores

Author: VaghinakDev

src/superannotate/__init__.py

@@ -99,13 +99,13 @@
 from superannotate.lib.app.interface.sdk_interface import (
     upload_images_from_public_urls_to_project,
 )
-from superannotate.lib.app.interface.sdk_interface import (
-    upload_priority_scores,
-)
 from superannotate.lib.app.interface.sdk_interface import upload_images_to_project
 from superannotate.lib.app.interface.sdk_interface import (
     upload_preannotations_from_folder_to_project,
 )
+from superannotate.lib.app.interface.sdk_interface import (
+    upload_priority_scores,
+)
 from superannotate.lib.app.interface.sdk_interface import upload_video_to_project
 from superannotate.lib.app.interface.sdk_interface import (
     upload_videos_from_folder_to_project,

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

@@ -39,8 +39,8 @@
 from lib.core.exceptions import AppException
 from lib.core.types import AttributeGroup
 from lib.core.types import MLModel
-from lib.core.types import Project
 from lib.core.types import PriorityScore
+from lib.core.types import Project
 from lib.infrastructure.controller import Controller
 from pydantic import conlist
 from pydantic import parse_obj_as
@@ -2895,11 +2895,11 @@ def get_annotations_per_frame(project: NotEmptyStr, video: NotEmptyStr, fps: int
         raise AppException(response.errors)
     return response.data
 
+
 @Trackable
 @validate_arguments
 def upload_priority_scores(project: NotEmptyStr, scores: List[PriorityScore]):
-    """
-    Returns per frame annotations for the given video.
+    """Returns per frame annotations for the given video.
 
     :param project: project name or folder path (e.g., “project1/folder1”)
     :type project: str
@@ -2912,14 +2912,7 @@ def upload_priority_scores(project: NotEmptyStr, scores: List[PriorityScore]):
     """
     project_name, folder_name = extract_project_folder(project)
     project_folder_name = project
-    use_case = Controller.get_default().upload_priority_scores(project_name, folder_name, scores, project_folder_name)
-    logger.info(f"Uploading  priority scores for {len(scores)} item(s) from {project_folder_name}.")
-    with tqdm(
-            total=len(scores), desc="Uploading priority scores"
-    ) as progress_bar:
-        for uploaded_count in use_case.execute():
-            progress_bar.update(uploaded_count)
-    progress_bar.close()
-    if use_case.response.errors:
-        raise AppException(use_case.errors)
-    return use_case.response.data
+    response = Controller.get_default().upload_priority_scores(project_name, folder_name, scores, project_folder_name)
+    if response.errors:
+        raise AppException(response.errors)
+    return response.data

src/superannotate/lib/app/mixp/utils/parsers.py

@@ -1234,4 +1234,4 @@ def upload_priority_scores(*args, **kwargs):
     return {
         "event_name": "upload_priority_scores",
         "properties": {"Score Count": len(scores)},
-    }
+    }

src/superannotate/lib/core/serviceproviders.py

@@ -316,7 +316,6 @@ def get_annotations(
         raise NotImplementedError
 
     def upload_priority_scores(
-            self, team_id: int, project_id: int, folder_id: int, priorities: list = []
-    ) -> ServiceResponse:
+            self, team_id: int, project_id: int, folder_id: int, priorities: list
+    ) -> dict:
         raise NotImplementedError
-

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

@@ -24,16 +24,16 @@
 from lib.core.exceptions import AppException
 from lib.core.reporter import Reporter
 from lib.core.repositories import BaseManageableRepository
-from lib.core.usecases.base import BaseInteractiveUseCase
 from lib.core.service_types import UploadAnnotationAuthData
 from lib.core.serviceproviders import SuerannotateServiceProvider
+from lib.core.types import PriorityScore
 from lib.core.usecases.base import BaseReportableUseCae
 from lib.core.usecases.images import GetBulkImages
 from lib.core.usecases.images import ValidateAnnotationUseCase
 from lib.core.video_convertor import VideoFrameGenerator
 from superannotate.logger import get_default_logger
 from superannotate_schemas.validators import AnnotationValidators
-from lib.core.types import PriorityScore
+
 
 logger = get_default_logger()
 
@@ -597,19 +597,20 @@ def execute(self):
         return self._response
 
 
-class UploadPriorityScoresUseCase(BaseInteractiveUseCase):
+class UploadPriorityScoresUseCase(BaseReportableUseCae):
 
     CHUNK_SIZE = 100
 
     def __init__(
         self,
+        reporter,
         project: ProjectEntity,
         folder: FolderEntity,
         scores: List[PriorityScore],
         project_folder_name: str,
         backend_service_provider: SuerannotateServiceProvider
     ):
-        super().__init__()
+        super().__init__(reporter)
         self._project = project
         self._folder = folder
         self._scores = scores
@@ -629,29 +630,37 @@ def get_clean_priority(priority):
                 priority = float(str(float(priority)).split('.')[0] + '.' + str(float(priority)).split('.')[1][:5])
         return priority
 
-    def execute(self):
-        priorities = []
-        to_send = []
-        for i in self._scores:
-            priorities.append({
-                "name": i.name,
-                "entropy_value": self.get_clean_priority(i.priority)
-            })
-            to_send.append(i.name)
-
-        uploaded = []
-        for i in range(0, len(priorities), self.CHUNK_SIZE):
-            res = self._client.upload_priority_scores(
-                team_id=self._project.team_id,
-                project_id=self._project.uuid,
-                folder_id=self._folder.uuid,
-                priorities=priorities[i : i + self.CHUNK_SIZE],  # noqa: E203
-            )
-            uploaded += res["data"]
-            yield len(to_send[:i + self.CHUNK_SIZE])
+    @property
+    def folder_path(self):
+        return f"{self._project.name}{f'/{self._folder.name}'if self._folder.name != 'root' else ''}"
 
-        uploaded = [i["name"] for i in uploaded]
-        skipped = list(set(to_send) - set(uploaded))
-        self._response.data = (uploaded, skipped)
+    def execute(self):
+        if self.is_valid():
+            priorities = []
+            initial_scores = []
+            for i in self._scores:
+                priorities.append({
+                    "name": i.name,
+                    "entropy_value": self.get_clean_priority(i.priority)
+                })
+                initial_scores.append(i.name)
+            uploaded_score_names = []
+            self.reporter.log_info(f"Uploading  priority scores for {len(priorities)} item(s) from {self.folder_path}.")
+            iterations = range(0, len(priorities), self.CHUNK_SIZE)
+            self.reporter.start_progress(iterations, "Uploading priority scores")
+            if iterations:
+                for i in iterations:
+                    priorities_to_upload = priorities[i : i + self.CHUNK_SIZE]  # noqa: E203
+                    res = self._client.upload_priority_scores(
+                        team_id=self._project.team_id,
+                        project_id=self._project.uuid,
+                        folder_id=self._folder.uuid,
+                        priorities=priorities_to_upload
+                    )
+                    self.reporter.update_progress(len(priorities_to_upload))
+                    uploaded_score_names.extend(list(map(lambda x: x["name"], res.get("data", []))))
+                skipped_score_names = list(set(initial_scores) - set(uploaded_score_names))
+                self._response.data = (uploaded_score_names, skipped_score_names)
+            else:
+                self.reporter.warning_messages("Empty scores.")
         return self._response
-

src/superannotate/lib/infrastructure/controller.py

@@ -38,6 +38,7 @@
 
 
 class BaseController(metaclass=ABCMeta):
+
     def __init__(self, config_path: str = None, token: str = None):
         self._team_data = None
         self._token = None
@@ -1652,10 +1653,11 @@ def upload_priority_scores(self, project_name, folder_name, scores, project_fold
         project = self._get_project(project_name)
         folder = self._get_folder(project, folder_name)
         use_case = usecases.UploadPriorityScoresUseCase(
+            reporter=self.default_reporter,
             project=project,
             folder=folder,
             scores=scores,
             backend_service_provider=self.backend_client,
             project_folder_name=project_folder_name
         )
-        return use_case
+        return use_case.execute()

src/superannotate/lib/infrastructure/services.py

@@ -227,8 +227,8 @@ class SuperannotateBackendService(BaseBackendService):
     URL_UPLOAD_PRIORITY_SCORES = "images/updateEntropy"
 
     def upload_priority_scores(
-            self, team_id: int, project_id: int, folder_id: int, priorities: list = []
-    ) -> ServiceResponse:
+            self, team_id: int, project_id: int, folder_id: int, priorities: list
+    ) -> dict:
         upload_priority_score_url = urljoin(self.api_url, self.URL_UPLOAD_PRIORITY_SCORES)
         res = self._request(
             upload_priority_score_url,

tests/integration/test_upload_priority_scores.py

@@ -1,7 +1,9 @@
 import os
+from pathlib import Path
+
 import src.superannotate as sa
 from tests.integration.base import BaseTestCase
-from pathlib import Path
+
 
 class TestUploadPriorityScores(BaseTestCase):
     PROJECT_NAME = "TestUploadPriorityScores"
@@ -17,7 +19,7 @@ def test_upload_priority_scores(self):
         sa.upload_images_from_folder_to_project(
             self.PROJECT_NAME, self.folder_path, annotation_status="InProgress"
         )
-        uploaded, skipped = sa.upload_priority_scores(self.PROJECT_NAME, scores=[{
+        uploaded, skipped = sa.upload_priority_2scores(self.PROJECT_NAME, scores=[{
             "name": "example_image_1.jpg",
             "priority": 1
         }])
@@ -39,5 +41,5 @@ def test_upload_priority_scores(self):
             "name": "example_image_4.jpg",
             "priority": 100000000
         }])
-        self.assertEqual(sa.get_image_metadata(self.PROJECT_NAME,"example_image_4.jpg")['entropy_value'], 1000000)
-        self.assertEqual(sa.get_image_metadata(self.PROJECT_NAME,"example_image_3.jpg")['entropy_value'], 1.12345)
+        self.assertEqual(sa.get_image_metadata(self.PROJECT_NAME, "example_image_4.jpg")['entropy_value'], 1000000)
+        self.assertEqual(sa.get_image_metadata(self.PROJECT_NAME, "example_image_3.jpg")['entropy_value'], 1.12345)