fix video convertor

Author: VaghinakDev

requirements_dev.txt

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

src/superannotate/__init__.py

@@ -211,8 +211,7 @@
 
 __author__ = "Superannotate"
 
-WORKING_DIR = os.path.split(os.path.realpath(__file__))[0]
-sys.path.append(WORKING_DIR)
+sys.path.append(os.path.split(os.path.realpath(__file__))[0])
 logging.getLogger("botocore").setLevel(logging.CRITICAL)
 logger = get_default_logger()
 

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

@@ -1620,7 +1620,7 @@ def execute(self) -> Response:
                 polling_states[response.get("poll_id")] = False
 
         if not polling_states:
-            self._response.errors = AppException("Invalid image names or empty folder.")
+            self._response.errors = AppException("Invalid item names or empty folder.")
         else:
             for poll_id in polling_states:
                 timeout_start = time.time()

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

@@ -202,17 +202,16 @@ def upload_to_s3_from_folder(self, source: str, folder_path: str):
 
         def _upload_file_to_s3(_to_s3_bucket, _path, _s3_key) -> None:
             _to_s3_bucket.upload_file(str(_path), _s3_key)
-            self.reporter.update_progress()
 
         with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
             results = []
-            self.reporter.start_progress(len(files_to_upload), "Uploading")
+            self.reporter.start_spinner()
             for path in files_to_upload:
                 s3_key = f"{folder_path + '/' if folder_path else ''}{str(Path(path).relative_to(Path(source)))}"
                 results.append(
                     executor.submit(_upload_file_to_s3, to_s3_bucket, path, s3_key)
                 )
-            self.reporter.finish_progress()
+            self.reporter.stop_spinner()
 
     def download_to_local_storage(self, destination: str, extract_zip=False):
         exports = self._service.get_exports(
@@ -227,22 +226,22 @@ def download_to_local_storage(self, destination: str, extract_zip=False):
         if not export:
             raise AppException("Export not found.")
         export_status = export["status"]
-
-        while export_status != ExportStatus.COMPLETE.value:
-            logger.info("Waiting 5 seconds for export to finish on server.")
-            time.sleep(5)
-
-            export = self._service.get_export(
-                team_id=self._project.team_id,
-                project_id=self._project.id,
-                export_id=export["id"],
-            )
-            if "error" in export:
-                raise AppException(export["error"])
-            export_status = export["status"]
-            if export_status in (ExportStatus.ERROR.value, ExportStatus.CANCELED.value):
-                raise AppException("Couldn't download export.")
-
+        if export_status != ExportStatus.COMPLETE.value:
+            logger.info("Waiting for export to finish on server.")
+            self.reporter.start_spinner()
+            while export_status != ExportStatus.COMPLETE.value:
+                export = self._service.get_export(
+                    team_id=self._project.team_id,
+                    project_id=self._project.id,
+                    export_id=export["id"],
+                )
+                if "error" in export:
+                    raise AppException(export["error"])
+                export_status = export["status"]
+                if export_status in (ExportStatus.ERROR.value, ExportStatus.CANCELED.value):
+                    self.reporter.stop_spinner()
+                    raise AppException("Couldn't download export.")
+            self.reporter.stop_spinner()
         filename = Path(export["path"]).name
         filepath = Path(destination) / filename
         with requests.get(export["download"], stream=True) as response:

src/superannotate/lib/core/video_convertor.py

@@ -36,7 +36,7 @@ def __init__(self, annotation_data: dict, fps: int):
         self.fps = fps
         self.ratio = 1000 * 1000 / fps
         self._frame_id = 1
-        self.frames_count = int(self.duration * fps)
+        self.frames_count = int(math.ceil(self.duration * fps))
         self.annotations: dict = {}
         self._mapping = {}
         self._process()
@@ -107,7 +107,7 @@ 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 / 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:]:
@@ -163,8 +163,6 @@ def _process(self):
             class_name = instance["meta"].get("className")
             for parameter in instance["parameters"]:
                 frames_mapping = defaultdict(list)
-                last_frame_no = None
-                last_annotation = None
                 interpolated_frames = {}
                 for timestamp in parameter["timestamps"]:
                     frames_mapping[
@@ -190,33 +188,35 @@ def _process(self):
                                 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])
-                    interpolated_frames[from_frame_no] = Annotation(
-                        instanceId=instance_id,
-                        type=annotation_type,
-                        className=class_name,
-                        x=start_median_frame.get("x"),
-                        y=start_median_frame.get("y"),
-                        points=start_median_frame.get("points"),
-                        attributes=start_median_frame["attributes"],
-                        keyframe=True,
-                    )
-                    last_annotation = Annotation(
+                    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,
+                            className=class_name,
+                            x=frame.get("x"),
+                            y=frame.get("y"),
+                            points=frame.get("points"),
+                            attributes=frame["attributes"],
+                            keyframe=True,
+                        )
+                if frames_mapping and not interpolated_frames:
+                    median = self.get_median(frames_mapping[1])
+                    interpolated_frames[1] = Annotation(
                         instanceId=instance_id,
                         type=annotation_type,
                         className=class_name,
-                        x=start_median_frame.get("x"),
-                        y=start_median_frame.get("y"),
-                        points=end_median_frame.get("points"),
-                        attributes=end_median_frame["attributes"],
+                        x=median.get("x"),
+                        y=median.get("y"),
+                        points=median.get("points"),
+                        attributes=median["attributes"],
                         keyframe=True,
                     )
-                self._add_annotation(last_frame_no, last_annotation)
-                [
+
+                for frame_no, annotation in interpolated_frames.items():
                     self._add_annotation(frame_no, annotation)
-                    for frame_no, annotation in interpolated_frames.items()
-                ]
 
     def __iter__(self):
         for frame_no in range(1, int(self.frames_count) + 1):

src/superannotate/lib/infrastructure/controller.py

@@ -1174,7 +1174,7 @@ def benchmark(
         if export_response.errors:
             return export_response
 
-        usecases.DownloadExportUseCase(
+        response = usecases.DownloadExportUseCase(
             service=self._backend_client,
             project=project,
             export_name=export_response.data["name"],
@@ -1183,7 +1183,8 @@ def benchmark(
             to_s3_bucket=False,
             reporter=self.default_reporter,
         ).execute()
-
+        if response.errors:
+            raise AppException(response.errors)
         use_case = usecases.BenchmarkUseCase(
             project=project,
             ground_truth_folder_name=ground_truth_folder_name,

src/superannotate/version.py

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

tests/integration/annotations/test_get_annotations_per_frame.py

@@ -1,4 +1,5 @@
 import json
+import math
 import os
 from os.path import dirname
 from pathlib import Path
@@ -47,8 +48,10 @@ def test_video_annotation_upload(self):
         self.assertEqual(
             len(annotations),
             int(
-                json.load(
-                    open(f"{self.annotations_path}/{self.VIDEO_NAME}.json"))["metadata"]["duration"] / (
-                        1000 * 1000)
+                math.ceil(
+                    json.load(
+                        open(f"{self.annotations_path}/{self.VIDEO_NAME}.json"))["metadata"]["duration"] / (
+                            1000 * 1000)
+                )
             )
         )