Merge pull request #412 from superannotateai/friday-964-priority

initial priority

Author: VaghinakDev

docs/source/superannotate.sdk.rst

@@ -92,6 +92,7 @@ ______
 .. autofunction:: superannotate.add_annotation_bbox_to_image
 .. autofunction:: superannotate.add_annotation_point_to_image
 .. autofunction:: superannotate.add_annotation_comment_to_image
+.. autofunction:: superannotate.upload_priority_scores
 
 ----------
 

src/superannotate/__init__.py

@@ -103,6 +103,9 @@
 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,
@@ -151,6 +154,7 @@
     "clone_project",
     "share_project",
     "delete_project",
+    "upload_priority_scores",
     # Images Section
     "search_images",
     "copy_image",

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

@@ -39,6 +39,7 @@
 from lib.core.exceptions import AppException
 from lib.core.types import AttributeGroup
 from lib.core.types import MLModel
+from lib.core.types import PriorityScore
 from lib.core.types import Project
 from lib.infrastructure.controller import Controller
 from pydantic import conlist
@@ -2900,3 +2901,25 @@ def get_annotations_per_frame(project: NotEmptyStr, video: NotEmptyStr, fps: int
     if response.errors:
         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.
+
+    :param project: project name or folder path (e.g., “project1/folder1”)
+    :type project: str
+
+    :param scores: list of score objects
+    :type scores: list of dicts
+
+    :return: lists of uploaded, skipped items
+    :rtype: tuple (2 members) of lists of strs
+    """
+    project_name, folder_name = extract_project_folder(project)
+    project_folder_name = project
+    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

@@ -1230,3 +1230,11 @@ def get_annotations_per_frame(*args, **kwargs):
         "event_name": "get_annotations_per_frame",
         "properties": {"Project": project, "fps": fps},
     }
+
+
+def upload_priority_scores(*args, **kwargs):
+    scores = kwargs.get("scores", args[1])
+    return {
+        "event_name": "upload_priority_scores",
+        "properties": {"Score Count": len(scores)},
+    }

src/superannotate/lib/core/serviceproviders.py

@@ -314,3 +314,8 @@ def get_annotations(
             reporter: Reporter
     ) -> List[dict]:
         raise NotImplementedError
+
+    def upload_priority_scores(
+            self, team_id: int, project_id: int, folder_id: int, priorities: list
+    ) -> dict:
+        raise NotImplementedError

src/superannotate/lib/core/types.py

@@ -40,3 +40,8 @@ class MLModel(BaseModel):
 
     class Config:
         extra = Extra.allow
+
+
+class PriorityScore(BaseModel):
+    name: NotEmptyStr
+    priority: float

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

@@ -26,13 +26,15 @@
 from lib.core.repositories import BaseManageableRepository
 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
 
+
 logger = get_default_logger()
 
 
@@ -622,3 +624,72 @@ def execute(self):
         else:
             self._response.errors = "Couldn't get annotations."
         return self._response
+
+
+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__(reporter)
+        self._project = project
+        self._folder = folder
+        self._scores = scores
+        self._client = backend_service_provider
+        self._project_folder_name = project_folder_name
+
+    @staticmethod
+    def get_clean_priority(priority):
+        if len(str(priority)) > 8:
+            priority = float(str(priority)[:8])
+        if priority > 1000000:
+            priority = 1000000
+        if priority < 0:
+            priority = 0
+        if str(float(priority)).split('.')[1:2]:
+            if len(str(float(priority)).split('.')[1]) > 5:
+                priority = float(str(float(priority)).split('.')[0] + '.' + str(float(priority)).split('.')[1][:5])
+        return priority
+
+    @property
+    def folder_path(self):
+        return f"{self._project.name}{f'/{self._folder.name}'if self._folder.name != 'root' else ''}"
+
+    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
@@ -1647,3 +1648,16 @@ def get_annotations_per_frame(self, project_name: str, folder_name: str, video_n
             backend_service_provider=self.backend_client
         )
         return use_case.execute()
+
+    def upload_priority_scores(self, project_name, folder_name, scores, project_folder_name):
+        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.execute()

src/superannotate/lib/infrastructure/services.py

@@ -224,6 +224,19 @@ class SuperannotateBackendService(BaseBackendService):
     URL_DELETE_ANNOTATIONS_PROGRESS = "annotations/getRemoveStatus"
     URL_GET_LIMITS = "project/{}/limitationDetails"
     URL_GET_ANNOTATIONS = "images/annotations/stream"
+    URL_UPLOAD_PRIORITY_SCORES = "images/updateEntropy"
+
+    def upload_priority_scores(
+            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,
+            "post",
+            params={"team_id": team_id, "project_id": project_id, "folder_id": folder_id},
+            data={"image_entropies": priorities}
+        )
+        return res.json()
 
     def get_project(self, uuid: int, team_id: int):
         get_project_url = urljoin(self.api_url, self.URL_GET_PROJECT.format(uuid))

tests/integration/test_upload_priority_scores.py

@@ -0,0 +1,45 @@
+import os
+from pathlib import Path
+
+import src.superannotate as sa
+from tests.integration.base import BaseTestCase
+
+
+class TestUploadPriorityScores(BaseTestCase):
+    PROJECT_NAME = "TestUploadPriorityScores"
+    PROJECT_DESCRIPTION = "Desc"
+    PROJECT_TYPE = "Vector"
+    TEST_FOLDER_PATH = "data_set/sample_project_vector"
+
+    @property
+    def folder_path(self):
+        return os.path.join(Path(__file__).parent.parent, self.TEST_FOLDER_PATH)
+
+    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_2scores(self.PROJECT_NAME, scores=[{
+            "name": "example_image_1.jpg",
+            "priority": 1
+        }])
+        self.assertEqual(len(uploaded), 1)
+        self.assertEqual(len(skipped), 0)
+        uploaded, skipped = sa.upload_priority_scores(self.PROJECT_NAME, scores=[{
+            "name": "non-exist.jpg",
+            "priority": 1
+        }, {
+            "name": "non-exist-2.jpg",
+            "priority": 1
+        }])
+        self.assertEqual(len(uploaded), 0)
+        self.assertEqual(len(skipped), 2)
+        uploaded, skipped = sa.upload_priority_scores(self.PROJECT_NAME, scores=[{
+            "name": "example_image_3.jpg",
+            "priority": 1.1234567890
+        }, {
+            "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)