Merge pull request #261 from superannotateai/fix-logs

Fix logs

Author: VaghinakDev

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

@@ -2447,22 +2447,23 @@ def upload_annotations_from_folder_to_project(
     project_name, folder_name = extract_project_folder(project)
     project_folder_name = project_name + (f"/{folder_name}" if folder_name else "")
 
-
     if recursive_subfolders:
         logger.info(
             "When using recursive subfolder parsing same name annotations in different "
             "subfolders will overwrite each other.",
         )
-    logger.info("The JSON files should follow a specific naming convention, matching file names already present "
-                "on the platform. Existing annotations will be overwritten")
+    logger.info(
+        "The JSON files should follow a specific naming convention, matching file names already present "
+        "on the platform. Existing annotations will be overwritten"
+    )
 
     annotation_paths = get_annotation_paths(
         folder_path, from_s3_bucket, recursive_subfolders
     )
-    if not annotation_paths:
-        raise AppException("Could not find annotations matching existing items on the platform.")
 
-    logger.info(f"Uploading {len(annotation_paths)} annotations from {folder_path} to the project {project_folder_name}.")
+    logger.info(
+        f"Uploading {len(annotation_paths)} annotations from {folder_path} to the project {project_folder_name}."
+    )
     response = controller.upload_annotations_from_folder(
         project_name=project_name,
         folder_name=folder_name,
@@ -2518,16 +2519,17 @@ def upload_preannotations_from_folder_to_project(
             "When using recursive subfolder parsing same name annotations in different "
             "subfolders will overwrite each other.",
         )
-    logger.info("The JSON files should follow a specific naming convention, matching file names already present "
-                "on the platform. Existing annotations will be overwritten")
+    logger.info(
+        "The JSON files should follow a specific naming convention, matching file names already present "
+        "on the platform. Existing annotations will be overwritten"
+    )
     logger.info("Existing annotations will be overwritten.",)
     annotation_paths = get_annotation_paths(
         folder_path, from_s3_bucket, recursive_subfolders
     )
-    if not annotation_paths:
-        raise AppException("Could not find annotations matching existing items on the platform.")
     logger.info(
-        f"Uploading {len(annotation_paths)} annotations from {folder_path} to the project {project_folder_name}.")
+        f"Uploading {len(annotation_paths)} annotations from {folder_path} to the project {project_folder_name}."
+    )
     response = controller.upload_annotations_from_folder(
         project_name=project_name,
         folder_name=folder_name,

src/superannotate/lib/core/helpers.py

@@ -8,10 +8,7 @@
 def map_annotation_classes_name(annotation_classes, reporter: Reporter) -> dict:
     classes_data = defaultdict(dict)
     for annotation_class in annotation_classes:
-        class_info = {
-            "id": annotation_class.uuid,
-            "attribute_groups": {}
-        }
+        class_info = {"id": annotation_class.uuid, "attribute_groups": {}}
         if annotation_class.attribute_groups:
             for attribute_group in annotation_class.attribute_groups:
                 attribute_group_data = defaultdict(dict)
@@ -46,14 +43,13 @@ def map_annotation_classes_name(annotation_classes, reporter: Reporter) -> dict:
 
 
 def fill_document_tags(
-    annotations: dict,
-    annotation_classes: dict,
+    annotations: dict, annotation_classes: dict,
 ):
     new_tags = []
-    for tag in annotations['tags']:
+    for tag in annotations["tags"]:
         if annotation_classes.get(tag):
-            new_tags.append(annotation_classes[tag]['id'])
-    annotations['tags'] = new_tags
+            new_tags.append(annotation_classes[tag]["id"])
+    annotations["tags"] = new_tags
 
 
 def fill_annotation_ids(
@@ -108,7 +104,10 @@ def fill_annotation_ids(
                 reporter.log_warning(
                     f"Couldn't find annotation group {attribute['groupName']}."
                 )
-                reporter.store_message("missing_attribute_groups", f"{annotation['className']}.{attribute['groupName']}")
+                reporter.store_message(
+                    "missing_attribute_groups",
+                    f"{annotation['className']}.{attribute['groupName']}",
+                )
                 continue
             attribute["groupId"] = annotation_classes_name_maps[annotation_class_name][
                 "attribute_groups"
@@ -131,7 +130,9 @@ def fill_annotation_ids(
             ][attribute["groupName"]]["attributes"][attribute["name"]]
 
 
-def convert_to_video_editor_json(data: dict, class_name_mapper: dict, reporter: Reporter):
+def convert_to_video_editor_json(
+    data: dict, class_name_mapper: dict, reporter: Reporter
+):
     id_generator = ClassIdGenerator()
 
     def safe_time(timestamp):
@@ -161,7 +162,9 @@ def convert_timestamp(timestamp):
             "locked": True,
         }
         if class_name:
-            editor_instance["classId"] = class_name_mapper.get(class_name, {}).get("id", id_generator.send(class_name))
+            editor_instance["classId"] = class_name_mapper.get(class_name, {}).get(
+                "id", id_generator.send(class_name)
+            )
         else:
             editor_instance["classId"] = id_generator.send("unknown_class")
         if meta.get("pointLabels", None):
@@ -194,13 +197,33 @@ def convert_timestamp(timestamp):
 
                 existing_attributes_in_current_instance = set()
                 for attribute in timestamp_data["attributes"]:
-                    group_name, attr_name = attribute.get("groupName"), attribute.get("name")
-                    if not class_name_mapper[class_name].get("attribute_groups", {}).get(group_name):
-                        reporter.store_message("missing_attribute_groups", f"{class_name}.{group_name}")
-                    elif not class_name_mapper[class_name]["attribute_groups"][group_name].get("attributes", {}).get(attr_name):
-                        reporter.store_message("missing_attributes", f"{class_name}.{group_name}.{attr_name}")
+                    group_name, attr_name = (
+                        attribute.get("groupName"),
+                        attribute.get("name"),
+                    )
+                    if (
+                        not class_name_mapper[class_name]
+                        .get("attribute_groups", {})
+                        .get(group_name)
+                    ):
+                        reporter.store_message(
+                            "missing_attribute_groups", f"{class_name}.{group_name}"
+                        )
+                    elif (
+                        not class_name_mapper[class_name]["attribute_groups"][
+                            group_name
+                        ]
+                        .get("attributes", {})
+                        .get(attr_name)
+                    ):
+                        reporter.store_message(
+                            "missing_attributes",
+                            f"{class_name}.{group_name}.{attr_name}",
+                        )
                     else:
-                        existing_attributes_in_current_instance.add((group_name, attr_name))
+                        existing_attributes_in_current_instance.add(
+                            (group_name, attr_name)
+                        )
                 attributes_to_add = (
                     existing_attributes_in_current_instance - active_attributes
                 )

src/superannotate/lib/core/types.py

@@ -48,7 +48,7 @@ class Metadata(BaseModel):
 
 
 class PointLabels(BaseModel):
-    __root__: Dict[constr(regex=r'^[0-9]*$'), str]
+    __root__: Dict[constr(regex=r"^[0-9]*$"), str]
 
 
 class BaseInstance(BaseModel):

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

@@ -12,7 +12,6 @@
 from lib.core.entities import FolderEntity
 from lib.core.entities import ImageEntity
 from lib.core.entities import ProjectEntity
-from lib.core.exceptions import AppException
 from lib.core.helpers import convert_to_video_editor_json
 from lib.core.helpers import fill_annotation_ids
 from lib.core.helpers import fill_document_tags
@@ -111,6 +110,7 @@ def annotations_to_upload(self):
                 for idx, detail in enumerate(images_detail):
                     if detail.name == image_data.name:
                         images_detail[idx] = detail._replace(id=image_data.uuid)
+                        break
 
             missing_annotations = list(
                 filter(lambda image_detail: image_detail.id is None, images_detail)
@@ -119,13 +119,8 @@ def annotations_to_upload(self):
                 filter(lambda image_detail: image_detail.id is not None, images_detail)
             )
             if missing_annotations:
-                for missing in missing_annotations:
-                    logger.warning(
-                        f"Couldn't find image {missing.path} for annotation upload."
-                    )
-            if not annotations_to_upload:
-                raise AppException(
-                    "No item to attach annotations."
+                logger.warning(
+                    f"Couldn't find {len(missing_annotations)}/{len(annotations_to_upload + missing_annotations)} items on the platform that match the annotations you want to upload."
                 )
             self._missing_annotations = missing_annotations
             self._annotations_to_upload = annotations_to_upload
@@ -199,9 +194,7 @@ def _log_report(self):
                 template = "Could not find attribute groups matching existing attribute groups on the platform: [{}]"
             elif key == "missing_attributes":
                 template = "Could not find attributes matching existing attributes on the platform: [{}]"
-            logger.warning(
-                template.format("', '".join(values))
-            )
+            logger.warning(template.format("', '".join(values)))
 
     def execute(self):
         uploaded_annotations = []
@@ -210,19 +203,27 @@ def execute(self):
             iterations_range = range(
                 0, len(self.annotations_to_upload), self.AUTH_DATA_CHUNK_SIZE
             )
-            self.reporter.start_progress(len(self.annotations_to_upload), description="Uploading Annotations")
+            self.reporter.start_progress(
+                len(self.annotations_to_upload), description="Uploading Annotations"
+            )
             for step in iterations_range:
-                annotations_to_upload = self.annotations_to_upload[step : step + self.AUTH_DATA_CHUNK_SIZE]  # noqa: E203
+                annotations_to_upload = self.annotations_to_upload[
+                    step : step + self.AUTH_DATA_CHUNK_SIZE
+                ]  # noqa: E203
                 upload_data = self.get_annotation_upload_data(
                     [int(image.id) for image in annotations_to_upload]
                 )
-                bucket = self.get_bucket_to_upload([int(image.id) for image in annotations_to_upload])
+                bucket = self.get_bucket_to_upload(
+                    [int(image.id) for image in annotations_to_upload]
+                )
                 if bucket:
                     image_id_name_map = {
                         image.id: image for image in self.annotations_to_upload
                     }
                     # dummy progress
-                    for _ in range(len(annotations_to_upload) - len(upload_data.images)):
+                    for _ in range(
+                        len(annotations_to_upload) - len(upload_data.images)
+                    ):
                         self.reporter.update_progress()
                     with concurrent.futures.ThreadPoolExecutor(
                         max_workers=self.MAX_WORKERS
@@ -252,8 +253,6 @@ def execute(self):
                 [annotation.path for annotation in self._missing_annotations],
             )
             self._log_report()
-        else:
-            self._response.errors = "Could not find annotations matching existing items on the platform."
         return self._response
 
 
@@ -338,13 +337,26 @@ def from_s3(self):
     def set_annotation_json(self):
         if not self._annotation_json:
             if self._client_s3_bucket:
-                self._annotation_json = json.load(self.get_s3_file(self.from_s3, self._annotation_path))
+                self._annotation_json = json.load(
+                    self.get_s3_file(self.from_s3, self._annotation_path)
+                )
                 if self._project.project_type == constances.ProjectType.PIXEL.value:
-                    self._mask = self.get_s3_file(self.from_s3, self._annotation_path.replace(constances.PIXEL_ANNOTATION_POSTFIX, constances.ANNOTATION_MASK_POSTFIX))
+                    self._mask = self.get_s3_file(
+                        self.from_s3,
+                        self._annotation_path.replace(
+                            constances.PIXEL_ANNOTATION_POSTFIX,
+                            constances.ANNOTATION_MASK_POSTFIX,
+                        ),
+                    )
             else:
                 self._annotation_json = json.load(open(self._annotation_path))
                 if self._project.project_type == constances.ProjectType.PIXEL.value:
-                    self._mask = open(self._annotation_path.replace(constances.PIXEL_ANNOTATION_POSTFIX, constances.ANNOTATION_MASK_POSTFIX))
+                    self._mask = open(
+                        self._annotation_path.replace(
+                            constances.PIXEL_ANNOTATION_POSTFIX,
+                            constances.ANNOTATION_MASK_POSTFIX,
+                        )
+                    )
 
     def _is_valid_json(self, json_data: dict):
         use_case = ValidateAnnotationUseCase(
@@ -368,7 +380,7 @@ def prepare_annotations(
         if project_type in (
             constances.ProjectType.VECTOR.value,
             constances.ProjectType.PIXEL.value,
-            constances.ProjectType.DOCUMENT.value
+            constances.ProjectType.DOCUMENT.value,
         ):
             fill_annotation_ids(
                 annotations=annotations,
@@ -415,7 +427,10 @@ def execute(self):
                     ],
                     Body=json.dumps(annotation_json),
                 )
-                if self._project.project_type == constances.ProjectType.PIXEL.value and self._mask:
+                if (
+                    self._project.project_type == constances.ProjectType.PIXEL.value
+                    and self._mask
+                ):
                     bucket.put_object(
                         Key=self.annotation_upload_data.images[self._image.uuid][
                             "annotation_bluemap_path"