supervisely 6.73.438__tar.gz → 6.73.440__tar.gz

{supervisely-6.73.438/supervisely.egg-info → supervisely-6.73.440}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.438
+Version: 6.73.440
 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.438 → supervisely-6.73.440}/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.438 → supervisely-6.73.440}/supervisely/__init__.py

@@ -318,3 +318,115 @@ except Exception as e:
 from supervisely.io.env import configure_minimum_instance_version
 
 configure_minimum_instance_version()
+
+LARGE_ENV_PLACEHOLDER = "@.@SLY_LARGE_ENV@.@"
+
+
+def restore_env_vars():
+    try:
+        large_env_keys = []
+        for key, value in os.environ.items():
+            if value == LARGE_ENV_PLACEHOLDER:
+                large_env_keys.append(key)
+        if len(large_env_keys) == 0:
+            return
+
+        if utils.is_development():
+            logger.info(
+                "Large environment variables detected. Skipping restoration in development mode.",
+                extra={"keys": large_env_keys},
+            )
+            return
+
+        unknown_keys = []
+        state_keys = []
+        context_keys = []
+        for key in large_env_keys:
+            if key == "CONTEXT" or key.startswith("context."):
+                context_keys.append(key)
+            elif key.startswith("MODAL_STATE") or key.startswith("modal.state."):
+                state_keys.append(key)
+            else:
+                unknown_keys.append(key)
+
+        if state_keys or context_keys:
+            api = Api()
+            if state_keys:
+                task_info = api.task.get_info_by_id(env.task_id())
+                state = task_info.get("meta", {}).get("params", {}).get("state", {})
+                modal_state_envs = json.flatten_json(state)
+                modal_state_envs = json.modify_keys(modal_state_envs, prefix="modal.state.")
+
+                restored_keys = []
+                not_found_keys = []
+                for key in state_keys:
+                    if key == "MODAL_STATE":
+                        os.environ[key] = json.json.dumps(state)
+                    elif key in modal_state_envs:
+                        os.environ[key] = str(modal_state_envs[key])
+                    elif key.replace("_", ".") in [k.upper() for k in modal_state_envs]:
+                        # some env vars do not support dots in their names
+                        k = next(k for k in modal_state_envs if k.upper() == key.replace("_", "."))
+                        os.environ[key] = str(modal_state_envs[k])
+                    else:
+                        not_found_keys.append(key)
+                        continue
+                    restored_keys.append(key)
+
+                if restored_keys:
+                    logger.info(
+                        "Restored large environment variables from task state",
+                        extra={"keys": restored_keys},
+                    )
+
+                if not_found_keys:
+                    logger.warning(
+                        "Failed to restore some large environment variables from task state. "
+                        "No such keys in the state.",
+                        extra={"keys": not_found_keys},
+                    )
+
+            if context_keys:
+                context = api.task.get_context(env.task_id())
+                context_envs = json.flatten_json(context)
+                context_envs = json.modify_keys(context_envs, prefix="context.")
+
+                restored_keys = []
+                not_found_keys = []
+                for key in context_keys:
+                    if key == "CONTEXT":
+                        os.environ[key] = json.json.dumps(context)
+                    elif key in context_envs:
+                        os.environ[key] = context_envs[key]
+                    else:
+                        not_found_keys.append(key)
+                        continue
+                    restored_keys.append(key)
+
+                if restored_keys:
+                    logger.info(
+                        "Restored large environment variables from task context",
+                        extra={"keys": restored_keys},
+                    )
+
+                if not_found_keys:
+                    logger.warning(
+                        "Failed to restore some large environment variables from task context. "
+                        "No such keys in the context.",
+                        extra={"keys": not_found_keys},
+                    )
+
+        if unknown_keys:
+            logger.warning(
+                "Found unknown large environment variables. Can't restore them.",
+                extra={"keys": unknown_keys},
+            )
+
+    except Exception as e:
+        logger.warning(
+            "Failed to restore large environment variables.",
+            exc_info=True,
+        )
+
+
+restore_env_vars()

{supervisely-6.73.438 → supervisely-6.73.440}/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.438 → supervisely-6.73.440}/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.438 → supervisely-6.73.440}/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.438 → supervisely-6.73.440}/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.438 → supervisely-6.73.440}/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]]`
         """