supervisely 6.73.439__tar.gz → 6.73.441__tar.gz

{supervisely-6.73.439/supervisely.egg-info → supervisely-6.73.441}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.439
+Version: 6.73.441
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely
@@ -117,6 +117,7 @@ Requires-Dist: tensorboard; extra == "tracking"
 Requires-Dist: decord; extra == "tracking"
 Requires-Dist: gdown; extra == "tracking"
 Requires-Dist: torch; extra == "tracking"
+Requires-Dist: motmetrics; extra == "tracking"
 Provides-Extra: model-benchmark
 Requires-Dist: pycocotools; extra == "model-benchmark"
 Requires-Dist: scikit-learn; extra == "model-benchmark"

{supervisely-6.73.439 → supervisely-6.73.441}/setup.py

@@ -201,7 +201,7 @@ setup(
             "app/development/*.sh",
             "imaging/colors.json.gz",
             "nn/benchmark/*/*.yaml",
-            "nn/tracker/botsort/botsort_config.yaml"
+            "nn/tracker/botsort/botsort_config.yaml",
         ],
     },
     entry_points={
@@ -276,6 +276,7 @@ setup(
             "decord",
             "gdown",
             "torch",
+            "motmetrics",
         ],
         "model-benchmark": [
             "pycocotools",

{supervisely-6.73.439 → supervisely-6.73.441}/supervisely/annotation/label.py

@@ -4,6 +4,8 @@
 # docs
 from __future__ import annotations
 
+
+from supervisely.collection.str_enum import StrEnum
 from copy import deepcopy
 from typing import Dict, List, Optional, Tuple, Union
 
@@ -45,6 +47,47 @@ class LabelJsonFields:
     """"""
     SMART_TOOL_INPUT = "smartToolInput"
     """"""
+    NN_CREATED = "nnCreated"
+    """Flag indicating if the label was created by NN model or manually."""
+    NN_UPDATED = "nnUpdated"
+    """Flag indicating if the label was corrected by NN model or manually."""
+
+class LabelingStatus(StrEnum):
+    """
+    Shows status of the label. Can be one of the following:
+
+    - AUTO: Specifies if the label was created by NN model.
+        - nn_created: True | Created by NN model
+        - nn_updated: True | Corrected by NN model
+    - MANUAL: Specifies if the label was created manually.
+        - nn_created: False | Manually created
+        - nn_updated: False | Not corrected by NN model
+    - CORRECTED: Specifies if the label was initially created by NN model and then manually corrected.
+        - nn_created: True | Created by NN model
+        - nn_updated: False | Manually corrected
+    """
+
+    AUTO = "auto"
+    MANUAL = "manual"
+    CORRECTED = "corrected"
+
+    @classmethod
+    def to_flags(cls, status: LabelingStatus) -> Tuple[bool, bool]:
+        if status == cls.AUTO:
+            return True, True
+        elif status == cls.CORRECTED:
+            return True, False
+        else:
+            return False, False
+
+    @classmethod
+    def from_flags(cls, nn_created: bool, nn_updated: bool) -> LabelingStatus:
+        if nn_created and nn_updated:
+            return cls.AUTO
+        elif nn_created and not nn_updated:
+            return cls.CORRECTED
+        else:
+            return cls.MANUAL
 
 
 class LabelBase:
@@ -65,6 +108,8 @@ class LabelBase:
     :type smart_tool_input: dict, optional
     :param sly_id: Label unique identifier.
     :type sly_id: int, optional
+    :param status: Sets labeling status. Shows how label was created and corrected.
+    :type status: LabelingStatus, optional
 
     :Usage example:
 
@@ -99,6 +144,7 @@ class LabelBase:
         binding_key: Optional[str] = None,
         smart_tool_input: Optional[Dict] = None,
         sly_id: Optional[int] = None,
+        status: Optional[LabelingStatus] = None,
     ):
         self._geometry = geometry
         self._obj_class = obj_class
@@ -112,9 +158,14 @@ class LabelBase:
 
         self._binding_key = binding_key
         self._smart_tool_input = smart_tool_input
-
         self._sly_id = sly_id
 
+        if status is None:
+            status = LabelingStatus.MANUAL
+        self._status = status
+        self._nn_created, self._nn_updated = LabelingStatus.to_flags(self.status)
+
+
     def _validate_geometry(self):
         """
         The function checks the name of the Object for compliance.
@@ -268,7 +319,9 @@ class LabelBase:
             #        "interior": []
             #    },
             #    "geometryType": "rectangle",
-            #    "shape": "rectangle"
+            #    "shape": "rectangle",
+            #    "nnCreated": false,
+            #    "nnUpdated": false
             # }
         """
         res = {
@@ -278,6 +331,8 @@ class LabelBase:
             **self.geometry.to_json(),
             GEOMETRY_TYPE: self.geometry.geometry_name(),
             GEOMETRY_SHAPE: self.geometry.geometry_name(),
+            LabelJsonFields.NN_CREATED: self._nn_created,
+            LabelJsonFields.NN_UPDATED: self._nn_updated,
         }
 
         if self.obj_class.sly_id is not None:
@@ -328,7 +383,9 @@ class LabelBase:
                 "points": {
                     "exterior": [[100, 100], [900, 700]],
                     "interior": []
-                }
+                },
+                "nnCreated": false,
+                "nnUpdated": false
             }
 
             label_dog = sly.Label.from_json(data, meta)
@@ -352,6 +409,10 @@ class LabelBase:
         binding_key = data.get(LabelJsonFields.INSTANCE_KEY)
         smart_tool_input = data.get(LabelJsonFields.SMART_TOOL_INPUT)
 
+        nn_created = data.get(LabelJsonFields.NN_CREATED, False)
+        nn_updated = data.get(LabelJsonFields.NN_UPDATED, False)
+        status = LabelingStatus.from_flags(nn_created, nn_updated)
+
         return cls(
             geometry=geometry,
             obj_class=obj_class,
@@ -360,6 +421,7 @@ class LabelBase:
             binding_key=binding_key,
             smart_tool_input=smart_tool_input,
             sly_id=data.get(LabelJsonFields.ID),
+            status=status,
         )
 
     @property
@@ -441,6 +503,7 @@ class LabelBase:
         description: Optional[str] = None,
         binding_key: Optional[str] = None,
         smart_tool_input: Optional[Dict] = None,
+        status: Optional[LabelingStatus] = None,
     ) -> LabelBase:
         """
         Makes a copy of Label with new fields, if fields are given, otherwise it will use fields of the original Label.
@@ -457,6 +520,8 @@ class LabelBase:
         :type binding_key: str, optional
         :param smart_tool_input: Smart Tool parameters that were used for labeling.
         :type smart_tool_input: dict, optional
+        :param status: Sets labeling status. Specifies if the label was created by NN model, manually or created by NN and then manually corrected.
+        :type status: LabelingStatus, optional
         :return: New instance of Label
         :rtype: :class:`Label<LabelBase>`
         :Usage example:
@@ -501,6 +566,7 @@ class LabelBase:
             description=take_with_default(description, self.description),
             binding_key=take_with_default(binding_key, self.binding_key),
             smart_tool_input=take_with_default(smart_tool_input, self._smart_tool_input),
+            status=take_with_default(status, self.status),
         )
 
     def crop(self, rect: Rectangle) -> List[LabelBase]:
@@ -864,6 +930,17 @@ class LabelBase:
     def labeler_login(self):
         return self.geometry.labeler_login
 
+    @property
+    def status(self) -> LabelingStatus:
+        """Labeling status. Specifies if the Label was created by NN model, manually or created by NN and then manually corrected."""
+        return self._status
+
+    @status.setter
+    def status(self, status: LabelingStatus):
+        """Set labeling status."""
+        self._status = status
+        self._nn_created, self._nn_updated = LabelingStatus.to_flags(self.status)
+
     @classmethod
     def _to_pixel_coordinate_system_json(cls, data: Dict, image_size: List[int]) -> Dict:
         """

{supervisely-6.73.439 → supervisely-6.73.441}/supervisely/api/annotation_api.py

@@ -1312,14 +1312,14 @@ class AnnotationApi(ModuleApi):
 
             api.annotation.update_label(label_id, new_label)
         """
-        self._api.post(
-            "figures.editInfo",
-            {
-                ApiField.ID: label_id,
-                ApiField.TAGS: [tag.to_json() for tag in label.tags],
-                ApiField.GEOMETRY: label.geometry.to_json(),
-            },
-        )
+        payload = {
+            ApiField.ID: label_id,
+            ApiField.TAGS: [tag.to_json() for tag in label.tags],
+            ApiField.GEOMETRY: label.geometry.to_json(),
+            ApiField.NN_CREATED: label._nn_created,
+            ApiField.NN_UPDATED: label._nn_updated,
+        }
+        self._api.post("figures.editInfo", payload)
 
     def update_label_priority(self, label_id: int, priority: int) -> None:
         """Updates label's priority with given ID in Supervisely.

{supervisely-6.73.439 → supervisely-6.73.441}/supervisely/api/entity_annotation/figure_api.py

@@ -27,6 +27,7 @@ from supervisely._utils import batched, logger, run_coroutine
 from supervisely.api.module_api import ApiField, ModuleApi, RemoveableBulkModuleApi
 from supervisely.geometry.rectangle import Rectangle
 from supervisely.video_annotation.key_id_map import KeyIdMap
+from supervisely.annotation.label import LabelingStatus
 
 
 class FigureInfo(NamedTuple):
@@ -221,6 +222,8 @@ class FigureApi(RemoveableBulkModuleApi):
             "meta",
             "area",
             "priority",
+            "nnCreated",
+            "nnUpdated",
         ]
         return self._get_info_by_id(id, "figures.info", {ApiField.FIELDS: fields})
 
@@ -233,6 +236,7 @@ class FigureApi(RemoveableBulkModuleApi):
         geometry_type: str,
         track_id: Optional[int] = None,
         custom_data: Optional[dict] = None,
+        status: Optional[LabelingStatus] = None,
     ) -> int:
         """"""
         input_figure = {
@@ -242,6 +246,13 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.GEOMETRY: geometry_json,
         }
 
+        if status is None:
+            status = LabelingStatus.MANUAL
+
+        nn_created, nn_updated = LabelingStatus.to_flags(status)
+        input_figure[ApiField.NN_CREATED] = nn_created
+        input_figure[ApiField.NN_UPDATED] = nn_updated
+
         if track_id is not None:
             input_figure[ApiField.TRACK_ID] = track_id
 
@@ -376,6 +387,8 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.AREA,
             ApiField.PRIORITY,
             ApiField.CUSTOM_DATA,
+            ApiField.NN_CREATED,
+            ApiField.NN_UPDATED,
         ]
         figures_infos = self.get_list_all_pages(
             "figures.list",
@@ -496,6 +509,8 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.AREA,
             ApiField.PRIORITY,
             ApiField.CUSTOM_DATA,
+            ApiField.NN_CREATED,
+            ApiField.NN_UPDATED,
         ]
         if skip_geometry is True:
             fields = [x for x in fields if x != ApiField.GEOMETRY]
@@ -854,6 +869,8 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.AREA,
             ApiField.PRIORITY,
             ApiField.CUSTOM_DATA,
+            ApiField.NN_CREATED,
+            ApiField.NN_UPDATED,
         ]
         if skip_geometry is True:
             fields = [x for x in fields if x != ApiField.GEOMETRY]

{supervisely-6.73.439 → supervisely-6.73.441}/supervisely/api/image_api.py

@@ -70,7 +70,11 @@ from supervisely.api.module_api import (
     _get_single_item,
 )
 from supervisely.imaging import image as sly_image
-from supervisely.io.env import app_categories, increment_upload_count, add_uploaded_ids_to_env
+from supervisely.io.env import (
+    add_uploaded_ids_to_env,
+    app_categories,
+    increment_upload_count,
+)
 from supervisely.io.fs import (
     OFFSETS_PKL_BATCH_SIZE,
     OFFSETS_PKL_SUFFIX,
@@ -5519,3 +5523,66 @@ class ImageApi(RemoveableBulkModuleApi):
             method,
             {ApiField.IMAGES: images},
         )
+
+    def get_subsequent_image_ids(
+        self,
+        image_id: int,
+        images_count: Optional[int] = None,
+        job_id: Optional[int] = None,
+        params: Optional[dict] = None,
+        dataset_id: Optional[int] = None,
+        project_id: Optional[int] = None,
+    ) -> List[int]:
+        """
+        Get list of subsequent image IDs after the specified image ID.
+
+        :param image_id: Image ID in Supervisely.
+        :type image_id: int
+        :param images_count: Number of subsequent images to retrieve. If None, retrieves all subsequent images.
+        :type images_count: int, optional
+        :param job_id: Job ID to filter images. If None, does not filter by job ID.
+        :type job_id: int, optional
+        :param params: Additional parameters for filtering and sorting images.
+        :type params: dict, optional
+        :param dataset_id: Dataset ID to filter images.
+        :type dataset_id: int, optional
+        :param project_id: Project ID to filter images. If None, makes a request to retrieve it from the specified image.
+        :type project_id: int, optional
+        """
+        data = {
+            "recursive": True,
+            "projectId": project_id,
+            "filters": [],
+            "sort": "name",
+            "sort_order": "asc",
+        }
+
+        if params is not None:
+            data.update(params)
+
+        if data["projectId"] is None:
+            image_info = self.get_info_by_id(image_id)
+            if image_info is None:
+                raise ValueError(f"Image with ID {image_id} not found.")
+            project_id = self._api.dataset.get_info_by_id(image_info.dataset_id).project_id
+        if job_id is not None:
+            self._api.add_header("x-job-id", str(job_id))
+        if dataset_id is not None:
+            data["datasetId"] = dataset_id
+
+        image_infos = self.get_list_all_pages(
+            "images.list",
+            data,
+            limit=None,
+            return_first_response=False,
+        )
+        self._api.headers.pop("x-job-id", None)
+        image_ids = [img_info.id for img_info in image_infos]
+        if len(image_ids) == 0:
+            raise ValueError("No images found with the specified criteria.")
+        elif image_id not in image_ids:
+            raise ValueError(f"Image with ID {image_id} not found in the specified entity.")
+
+        target_idx = image_ids.index(image_id) + 1
+        to_idx = target_idx + images_count if images_count is not None else len(image_ids)
+        return image_ids[target_idx:to_idx]

{supervisely-6.73.439 → supervisely-6.73.441}/supervisely/api/module_api.py

@@ -709,6 +709,10 @@ class ApiField:
     """"""
     UNIQUE_ITEMS = "uniqueItems"
     """"""
+    NN_CREATED = "nnCreated"
+    """"""
+    NN_UPDATED = "nnUpdated"
+    """"""
 
 
 def _get_single_item(items):

{supervisely-6.73.439 → supervisely-6.73.441}/supervisely/api/video/video_figure_api.py

@@ -10,7 +10,7 @@ from supervisely.api.module_api import ApiField
 from supervisely.geometry.geometry import Geometry
 from supervisely.video_annotation.key_id_map import KeyIdMap
 from supervisely.video_annotation.video_figure import VideoFigure
-
+from supervisely.annotation.label import LabelingStatus
 
 class VideoFigureApi(FigureApi):
     """
@@ -26,6 +26,7 @@ class VideoFigureApi(FigureApi):
         geometry_type: str,
         track_id: Optional[int] = None,
         meta: Optional[dict] = None,
+        status: Optional[LabelingStatus] = None,
     ) -> int:
         """
         Create new VideoFigure for given frame in given video ID.
@@ -42,6 +43,10 @@ class VideoFigureApi(FigureApi):
         :type geometry_type: str
         :param track_id: int, optional.
         :type track_id: int, optional
+        :param meta: Meta data for VideoFigure.
+        :type meta: dict, optional
+        :param status: Labeling status. Specifies if the VideoFigure was created by NN model, manually or created by NN and then manually corrected.
+        :type status: LabelingStatus, optional
         :return: New figure ID
         :rtype: :class:`int`
         :Usage example:
@@ -64,13 +69,16 @@ class VideoFigureApi(FigureApi):
         """
         if meta is None:
             meta = {}
+        meta = {**(meta or {}), ApiField.FRAME: frame_index}
+
         return super().create(
             video_id,
             object_id,
-            {**meta, ApiField.FRAME: frame_index},
+            meta,
             geometry_json,
             geometry_type,
             track_id,
+            status=status,
         )
 
     def append_bulk(self, video_id: int, figures: List[VideoFigure], key_id_map: KeyIdMap) -> None:
@@ -115,13 +123,15 @@ class VideoFigureApi(FigureApi):
 
         self._append_bulk(video_id, figures_json, keys, key_id_map)
 
-    def update(self, figure_id: int, geometry: Geometry) -> None:
+    def update(self, figure_id: int, geometry: Geometry, status: Optional[LabelingStatus] = None) -> None:
         """Updates figure feometry with given ID in Supervisely with new Geometry object.
 
         :param figure_id: ID of the figure to update
         :type figure_id: int
         :param geometry: Supervisely Gepmetry object
         :type geometry: Geometry
+        :param status: Labeling status. Specifies if the VideoFigure was created by NN model, manually or created by NN and then manually corrected.
+        :type status: LabelingStatus, optional
         :Usage example:
 
          .. code-block:: python
@@ -141,13 +151,17 @@ class VideoFigureApi(FigureApi):
 
             api.video.figure.update(figure_id, new_geometry)
         """
-        self._api.post(
-            "figures.editInfo",
-            {
-                ApiField.ID: figure_id,
-                ApiField.GEOMETRY: geometry.to_json(),
-            },
-        )
+        payload = {
+            ApiField.ID: figure_id,
+            ApiField.GEOMETRY: geometry.to_json(),
+        }
+
+        if status is not None:
+            nn_created,nn_updated = LabelingStatus.to_flags(status)
+            payload[ApiField.NN_CREATED] = nn_created
+            payload[ApiField.NN_UPDATED] = nn_updated
+
+        self._api.post("figures.editInfo", payload)
 
     def download(
         self, dataset_id: int, video_ids: List[int] = None, skip_geometry: bool = False, **kwargs
@@ -161,7 +175,6 @@ class VideoFigureApi(FigureApi):
         :type video_ids: List[int], optional
         :param skip_geometry: Skip the download of figure geometry. May be useful for a significant api request speed increase in the large datasets.
         :type skip_geometry: bool
-
         :return: A dictionary where keys are video IDs and values are lists of figures.
         :rtype: :class: `Dict[int, List[FigureInfo]]`
         """

{supervisely-6.73.439 → supervisely-6.73.441}/supervisely/nn/inference/inference.py

@@ -45,7 +45,7 @@ from supervisely._utils import (
     rand_str,
 )
 from supervisely.annotation.annotation import Annotation
-from supervisely.annotation.label import Label
+from supervisely.annotation.label import Label, LabelingStatus
 from supervisely.annotation.obj_class import ObjClass
 from supervisely.annotation.tag_collection import TagCollection
 from supervisely.annotation.tag_meta import TagMeta, TagValueType
@@ -1269,16 +1269,16 @@ class Inference:
 
     def get_classes(self) -> List[str]:
         return self.classes
-    
+
     def _tracker_init(self, tracker: str, tracker_settings: dict):
         # Check if tracking is supported for this model
         info = self.get_info()
         tracking_support = info.get("tracking_on_videos_support", False)
-        
+
         if not tracking_support:
             logger.debug("Tracking is not supported for this model")
             return None
-        
+
         if tracker == "botsort":
             from supervisely.nn.tracker import BotSortTracker
             device = tracker_settings.get("device", self.device)
@@ -1289,7 +1289,6 @@ class Inference:
                 logger.warning(f"Unknown tracking type: {tracker}. Tracking is disabled.")
             return None
 
-
     def get_info(self) -> Dict[str, Any]:
         num_classes = None
         classes = None
@@ -1439,8 +1438,12 @@ class Inference:
                 # for example empty mask
                 continue
             if isinstance(label, list):
+                for lb in label:
+                    lb.status = LabelingStatus.AUTO
                 labels.extend(label)
                 continue
+
+            label.status = LabelingStatus.AUTO
             labels.append(label)
 
         # create annotation with correct image resolution
@@ -1872,7 +1875,7 @@ class Inference:
             n_frames = frames_reader.frames_count()
 
         self._tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
-        
+
         progress_total = (n_frames + step - 1) // step
         inference_request.set_stage(InferenceRequest.Stage.INFERENCE, 0, progress_total)
 
@@ -1896,32 +1899,31 @@ class Inference:
                 source=frames,
                 settings=inference_settings,
             )
-            
+
             if self._tracker is not None:
                 anns = self._apply_tracker_to_anns(frames, anns)
-                
+
             predictions = [
                 Prediction(ann, model_meta=self.model_meta, frame_index=frame_index)
                 for ann, frame_index in zip(anns, batch)
             ]
-            
+
             for pred, this_slides_data in zip(predictions, slides_data):
                 pred.extra_data["slides_data"] = this_slides_data
             batch_results = self._format_output(predictions)
-            
+
             inference_request.add_results(batch_results)
             inference_request.done(len(batch_results))
             logger.debug(f"Frames {batch[0]}-{batch[-1]} done.")
         video_ann_json = None
         if self._tracker is not None:
             inference_request.set_stage("Postprocess...", 0, 1)
-            
+
             video_ann_json = self._tracker.video_annotation.to_json()
             inference_request.done()
         result = {"ann": results, "video_ann": video_ann_json}
         inference_request.final_result = result.copy()
         return video_ann_json
-        
 
     def _inference_image_ids(
         self,
@@ -2102,7 +2104,7 @@ class Inference:
             n_frames = video_info.frames_count
 
         self._tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
-        
+
         logger.debug(
             f"Video info:",
             extra=dict(
@@ -2137,10 +2139,10 @@ class Inference:
                 source=frames,
                 settings=inference_settings,
             )
-            
+
             if self._tracker is not None:
                 anns = self._apply_tracker_to_anns(frames, anns)
-                
+
             predictions = [
                 Prediction(
                     ann,
@@ -2155,7 +2157,7 @@ class Inference:
             for pred, this_slides_data in zip(predictions, slides_data):
                 pred.extra_data["slides_data"] = this_slides_data
             batch_results = self._format_output(predictions)
-                    
+
             inference_request.add_results(batch_results)
             inference_request.done(len(batch_results))
             logger.debug(f"Frames {batch[0]}-{batch[-1]} done.")
@@ -2637,6 +2639,10 @@ class Inference:
         for prediction in predictions:
             ds_predictions[prediction.dataset_id].append(prediction)
 
+        def update_labeling_status(ann: Annotation) -> Annotation:
+            for label in ann.labels:
+                label.status = LabelingStatus.AUTO
+
         def _new_name(image_info: ImageInfo):
             name = Path(image_info.name)
             stem = name.stem
@@ -2712,8 +2718,15 @@ class Inference:
                     iou=iou_merge_threshold,
                     meta=project_meta,
                 )
+
+                # Update labeling status of new predictions before upload
+                anns_with_nn_flags = []
                 for pred, ann in zip(preds, anns):
+                    update_labeling_status(ann)
                     pred.annotation = ann
+                    anns_with_nn_flags.append(ann)
+
+                anns = anns_with_nn_flags
 
                 context.setdefault("image_info", {})
                 missing = [
@@ -2778,7 +2791,10 @@ class Inference:
                     iou=iou_merge_threshold,
                     meta=project_meta,
                 )
+
+                # Update labeling status of predicted labels before optional merge
                 for pred, ann in zip(preds, anns):
+                    update_labeling_status(ann)
                     pred.annotation = ann
 
                 if upload_mode in ["iou_merge", "append"]:
@@ -4141,14 +4157,14 @@ class Inference:
             matches = self._tracker.update(frame, ann)
             track_ids = [match["track_id"] for match in matches]
             tracked_labels = [match["label"] for match in matches]
-            
+
             filtered_annotation = ann.clone(
                 labels=tracked_labels,
                 custom_data=track_ids
             )
             updated_anns.append(filtered_annotation)
         return updated_anns
-                
+
     def _add_workflow_input(self, model_source: str, model_files: dict, model_info: dict):
         if model_source == ModelSource.PRETRAINED:
             checkpoint_url = model_info["meta"]["model_files"]["checkpoint"]