Convertor fix

Author: VaghinakDev

pytest.ini

@@ -2,4 +2,4 @@
 minversion = 3.7
 log_cli=true
 python_files = test_*.py
-;addopts = -n auto --dist=loadscope
+addopts = -n auto --dist=loadscope

requirements_dev.txt

@@ -1,2 +1,2 @@
-superannotate_schemas>=v1.0.43dev4
+superannotate_schemas>=v1.0.43dev5
 

src/superannotate/lib/app/analytics/aggregators.py

@@ -85,6 +85,22 @@ class DocumentRawData:
 
 
 class DataAggregator:
+    MAPPERS = {
+        "event": lambda annotation: None,
+        "bbox": lambda annotation: annotation["points"],
+        "polygon": lambda annotation: annotation["points"],
+        "polyline": lambda annotation: annotation["points"],
+        "cuboid": lambda annotation: annotation["points"],
+        "point": lambda annotation: {"x": annotation["x"], "y": annotation["y"]},
+        "annotation_type": lambda annotation: dict(
+            cx=annotation["cx"],
+            cy=annotation["cy"],
+            rx=annotation["rx"],
+            ry=annotation["ry"],
+            angle=annotation["angle"],
+        ),
+    }
+
     def __init__(
         self,
         project_type: str,
@@ -186,11 +202,12 @@ def aggregate_video_annotations_as_df(self, annotation_paths: List[str]):
             # append instances
             instances = annotation_data.get("instances", [])
             for idx, instance in enumerate(instances):
+                instance_type = instance["meta"].get("type", "event")
                 instance_raw = copy.copy(raw_data)
                 instance_raw.instanceId = int(idx)
                 instance_raw.instanceStart = instance["meta"].get("start")
                 instance_raw.instanceEnd = instance["meta"].get("end")
-                instance_raw.type = instance["meta"].get("type")
+                instance_raw.type = instance_type
                 instance_raw.className = instance["meta"].get("className")
                 instance_raw.createdAt = instance["meta"].get("createdAt")
                 instance_raw.createdBy = (
@@ -217,7 +234,7 @@ def aggregate_video_annotations_as_df(self, annotation_paths: List[str]):
                     for timestamp_id, timestamp in enumerate(timestamps):
                         timestamp_raw = copy.copy(parameter_raw)
                         timestamp_raw.timestampId = timestamp_id
-                        timestamp_raw.meta = timestamp.get("points")
+                        timestamp_raw.meta = self.MAPPERS[instance_type](timestamp)
                         attributes = timestamp.get("attributes", [])
                         for attribute_id, attribute in enumerate(attributes):
                             attribute_raw = copy.copy(timestamp_raw)
@@ -467,8 +484,7 @@ def __append_annotation(annotation_dict):
                             ]
                         ):
                             logger.warning(
-                                "Annotation class group value %s not in classes json. Skipping.",
-                                attribute_name,
+                                f"Annotation class group value {attribute_name} not in classes json. Skipping."
                             )
                             continue
                         annotation_dict = {

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

@@ -2144,6 +2144,8 @@ def upload_image_to_project(
         raise AppException(response.errors)
 
 
+@Trackable
+@validate_arguments
 def search_models(
     name: Optional[NotEmptyStr] = None,
     type_: Optional[NotEmptyStr] = None,

src/superannotate/lib/core/data_handlers.py

@@ -47,7 +47,7 @@ def get_annotation_class(self, name: str) -> AnnotationClass:
 
     @lru_cache()
     def get_attribute_group(
-            self, annotation_class: AnnotationClass, attr_group_name: str
+        self, annotation_class: AnnotationClass, attr_group_name: str
     ) -> AttributeGroup:
         for attr_group in annotation_class.attribute_groups:
             if attr_group.name == attr_group_name:
@@ -114,10 +114,10 @@ def handle(self, annotation: dict):
 
 class MissingIDsHandler(BaseAnnotationDateHandler):
     def __init__(
-            self,
-            annotation_classes: List[AnnotationClass],
-            templates: List[dict],
-            reporter: Reporter,
+        self,
+        annotation_classes: List[AnnotationClass],
+        templates: List[dict],
+        reporter: Reporter,
     ):
         super().__init__(annotation_classes)
         self.validate_existing_classes(annotation_classes)
@@ -187,7 +187,7 @@ def handle(self, annotation: dict):
             template["name"]: template["id"] for template in self._templates
         }
         for annotation_instance in (
-                i for i in annotation["instances"] if i.get("type", None) == "template"
+            i for i in annotation["instances"] if i.get("type", None) == "template"
         ):
             annotation_instance["templateId"] = template_name_id_map.get(
                 annotation_instance.get("templateName", ""), -1
@@ -244,10 +244,14 @@ def _point_handler(time_stamp):
     HANDLERS: Dict[str, Callable] = {
         AnnotationTypes.EVENT: lambda timestamp: {},
         AnnotationTypes.BBOX: lambda timestamp: {"points": timestamp["points"]},
-        AnnotationTypes.POINT: lambda timestamp: {"x": timestamp["x"], "y": timestamp["y"]},
+        AnnotationTypes.POINT: lambda timestamp: {
+            "x": timestamp["x"],
+            "y": timestamp["y"],
+        },
         AnnotationTypes.POLYLINE: lambda timestamp: {"points": timestamp["points"]},
         AnnotationTypes.POLYGON: lambda timestamp: {
-            "points": timestamp["points"], "exclude": timestamp.get("exclude", [])
+            "points": timestamp["points"],
+            "exclude": timestamp.get("exclude", []),
         },
     }
 
@@ -315,7 +319,9 @@ def convert_timestamp(timestamp):
                         editor_instance["timeline"][timestamp]["active"] = False
                     handler: Callable = self.HANDLERS.get(meta["type"])
                     if handler:
-                        editor_instance["timeline"][timestamp].update(handler(timestamp_data))
+                        editor_instance["timeline"][timestamp].update(
+                            handler(timestamp_data)
+                        )
                     # if timestamp_data.get("points", None):
                     #     editor_instance["timeline"][timestamp][
                     #         "points"
@@ -357,10 +363,10 @@ def convert_timestamp(timestamp):
                                 (group_name, attr_name)
                             )
                     attributes_to_add = (
-                            existing_attributes_in_current_instance - active_attributes
+                        existing_attributes_in_current_instance - active_attributes
                     )
                     attributes_to_delete = (
-                            active_attributes - existing_attributes_in_current_instance
+                        active_attributes - existing_attributes_in_current_instance
                     )
                     if attributes_to_add or attributes_to_delete:
                         editor_instance["timeline"][timestamp][

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

@@ -238,7 +238,10 @@ def download_to_local_storage(self, destination: str, extract_zip=False):
                 if "error" in export:
                     raise AppException(export["error"])
                 export_status = export["status"]
-                if export_status in (ExportStatus.ERROR.value, ExportStatus.CANCELED.value):
+                if export_status in (
+                    ExportStatus.ERROR.value,
+                    ExportStatus.CANCELED.value,
+                ):
                     self.reporter.stop_spinner()
                     raise AppException("Couldn't download export.")
             self.reporter.stop_spinner()

src/superannotate/lib/core/video_convertor.py

@@ -56,14 +56,14 @@ def get_frame(self, frame_no: int):
             return self.annotations[frame_no]
 
     def _interpolate(
-            self,
-            class_name: str,
-            from_frame: int,
-            to_frame: int,
-            data: dict,
-            instance_id: int,
-            steps: dict = None,
-            annotation_type: str = "bbox",
+        self,
+        class_name: str,
+        from_frame: int,
+        to_frame: int,
+        data: dict,
+        instance_id: int,
+        steps: dict = None,
+        annotation_type: str = "bbox",
     ) -> dict:
         annotations = {}
         for idx, frame_idx in enumerate(range(from_frame + 1, to_frame), 1):
@@ -78,10 +78,12 @@ def _interpolate(
             elif annotation_type == AnnotationTypes.POINT:
                 tmp_data = {
                     "x": round(data["x"] + steps["x"] * idx, 2),
-                    "y": round(data["y"] + steps["y"] * idx, 2)
+                    "y": round(data["y"] + steps["y"] * idx, 2),
                 }
             elif annotation_type in (AnnotationTypes.POLYGON, AnnotationTypes.POLYLINE):
-                tmp_data["points"] = [point + steps[idx] * 2 for idx, point in enumerate(data["points"])]
+                tmp_data["points"] = [
+                    point + steps[idx] * 2 for idx, point in enumerate(data["points"])
+                ]
             annotations[frame_idx] = Annotation(
                 instanceId=instance_id,
                 type=annotation_type,
@@ -107,7 +109,9 @@ def get_median(self, annotations: List[dict]) -> dict:
         if len(annotations) == 1:
             return annotations[0]
         first_annotations = annotations[:1][0]
-        median = (first_annotations["timestamp"] // self.ratio) * self.ratio + self.ratio / 2
+        median = (
+            first_annotations["timestamp"] // self.ratio
+        ) * self.ratio + self.ratio / 2
         median_annotation = first_annotations
         distance = abs(median - first_annotations["timestamp"])
         for annotation in annotations[1:]:
@@ -131,29 +135,49 @@ def merge_first_frame(frames_mapping):
             return frames_mapping
 
     def _interpolate_frames(
-            self, from_frame, from_frame_no, to_frame, to_frame_no, annotation_type, class_name, instance_id
+        self,
+        from_frame,
+        from_frame_no,
+        to_frame,
+        to_frame_no,
+        annotation_type,
+        class_name,
+        instance_id,
     ):
         steps = None
         frames_diff = to_frame_no - from_frame_no
-        if annotation_type == AnnotationTypes.BBOX and from_frame.get("points") and to_frame.get("points"):
+        if (
+            annotation_type == AnnotationTypes.BBOX
+            and from_frame.get("points")
+            and to_frame.get("points")
+        ):
             steps = {}
             for point in "x1", "x2", "y1", "y2":
                 steps[point] = round(
-                    (to_frame["points"][point] - from_frame["points"][point]) / frames_diff, 2
+                    (to_frame["points"][point] - from_frame["points"][point])
+                    / frames_diff,
+                    2,
                 )
         elif annotation_type == AnnotationTypes.POINT:
             steps = {
                 "x": (to_frame["x"] - from_frame["x"]) / frames_diff,
-                "y": (to_frame["y"] - from_frame["y"]) / frames_diff
+                "y": (to_frame["y"] - from_frame["y"]) / frames_diff,
             }
         elif annotation_type in (AnnotationTypes.POLYGON, AnnotationTypes.POLYLINE):
             steps = [
                 (to_point - from_point) / frames_diff
-                for from_point, to_point in zip(from_frame["points"], to_frame["points"])
+                for from_point, to_point in zip(
+                    from_frame["points"], to_frame["points"]
+                )
             ]
         return self._interpolate(
-            class_name=class_name, from_frame=from_frame_no, to_frame=to_frame_no, data=from_frame,
-            instance_id=instance_id, steps=steps, annotation_type=annotation_type
+            class_name=class_name,
+            from_frame=from_frame_no,
+            to_frame=to_frame_no,
+            data=from_frame,
+            instance_id=instance_id,
+            steps=steps,
+            annotation_type=annotation_type,
         )
 
     def _process(self):
@@ -185,13 +209,16 @@ def _process(self):
                                 to_frame_no=to_frame_no,
                                 class_name=class_name,
                                 annotation_type=annotation_type,
-                                instance_id=instance_id
+                                instance_id=instance_id,
                             )
                         )
 
                     start_median_frame = self.get_median(frames_mapping[from_frame_no])
                     end_median_frame = self.get_median(frames_mapping[to_frame_no])
-                    for frame_no, frame in (from_frame_no, start_median_frame), (last_frame_no, end_median_frame):
+                    for frame_no, frame in (
+                        (from_frame_no, start_median_frame),
+                        (last_frame_no, end_median_frame),
+                    ):
                         interpolated_frames[frame_no] = Annotation(
                             instanceId=instance_id,
                             type=annotation_type,

src/superannotate/lib/infrastructure/controller.py

@@ -1216,16 +1216,15 @@ def consensus(
         if export_response.errors:
             return export_response
 
-        download_export_usecase = self.download_export(
+        response = self.download_export(
             project_name=project.name,
             export_name=export_response.data["name"],
             folder_path=export_path,
             extract_zip_contents=True,
             to_s3_bucket=False,
         )
-        for _ in download_export_usecase.execute():
-            continue
-
+        if response.errors:
+            raise AppException(response.errors)
         use_case = usecases.ConsensusUseCase(
             project=project,
             folder_names=folder_names,

src/superannotate/lib/infrastructure/services.py

@@ -86,7 +86,7 @@ def default_headers(self):
             "authtype": self.AUTH_TYPE,
             "Content-Type": "application/json",
             "User-Agent": f"Python-SDK-Version: {__version__}; Python: {platform.python_version()}; "
-                          f"OS: {platform.system()}; Team: {self.team_id}",
+            f"OS: {platform.system()}; Team: {self.team_id}",
         }
 
     @property

src/superannotate/version.py

@@ -1 +1 @@
-__version__ = "4.3.4dev2"
+__version__ = "4.3.4dev3"