supervisely 6.73.438__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/__init__.py

@@ -8,6 +8,22 @@ try:
 except TypeError as e:
     __version__ = "development"
 
+
+class _ApiProtoNotAvailable:
+    """Placeholder class that raises an error when accessing any attribute"""
+
+    def __getattr__(self, name):
+        from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+        raise ImportError(f"Cannot access `api_proto.{name}` : " + PROTOBUF_REQUIRED_ERROR)
+
+    def __bool__(self):
+        return False
+
+    def __repr__(self):
+        return "<api_proto: not available - install supervisely[agent] to enable>"
+
+
 from supervisely.sly_logger import (
     logger,
     ServiceType,
@@ -90,6 +106,7 @@ from supervisely.geometry.graph import GraphNodes, Node
 from supervisely.geometry.multichannel_bitmap import MultichannelBitmap
 from supervisely.geometry.alpha_mask import AlphaMask
 from supervisely.geometry.cuboid_2d import Cuboid2d
+from supervisely.geometry.oriented_bbox import OrientedBBox
 
 from supervisely.geometry.helpers import geometry_to_bitmap
 from supervisely.geometry.helpers import deserialize_geometry
@@ -112,7 +129,14 @@ from supervisely.worker_api.chunking import (
     ChunkedFileWriter,
     ChunkedFileReader,
 )
-import supervisely.worker_proto.worker_api_pb2 as api_proto
+
+# Global import of api_proto works only if protobuf is installed and compatible
+# Otherwise, we use a placeholder that raises an error when accessed
+try:
+    import supervisely.worker_proto.worker_api_pb2 as api_proto
+except Exception:
+    api_proto = _ApiProtoNotAvailable()
+
 
 from supervisely.api.api import Api, UserSession, ApiContext
 from supervisely.api import api
@@ -318,3 +342,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/_utils.py

@@ -319,6 +319,87 @@ def resize_image_url(
         return full_storage_url
 
 
+def get_storage_url(
+    entity_type: Literal["dataset-entities", "dataset", "project", "file-storage"],
+    entity_id: int,
+    source_type: Literal["original", "preview"],
+) -> str:
+    """
+    Generate URL for storage resources endpoints.
+
+    :param entity_type: Type of entity ("dataset-entities", "dataset", "project", "file-storage")
+    :type entity_type: str
+    :param entity_id: ID of the entity
+    :type entity_id: int
+    :param source_type: Type of source ("original" or "preview")
+    :type source_type: Literal["original", "preview"]
+    :return: Storage URL
+    :rtype: str
+    """
+    relative_url = f"/storage-resources/{entity_type}/{source_type}/{entity_id}"
+    if is_development():
+        return abs_url(relative_url)
+    return relative_url
+
+
+def get_image_storage_url(image_id: int, source_type: Literal["original", "preview"]) -> str:
+    """
+    Generate URL for image storage resources.
+
+    :param image_id: ID of the image
+    :type image_id: int
+    :param source_type: Type of source ("original" or "preview")
+    :type source_type: Literal["original", "preview"]
+    :return: Storage URL for image
+    :rtype: str
+    """
+    return get_storage_url("dataset-entities", image_id, source_type)
+
+
+def get_dataset_storage_url(
+    dataset_id: int, source_type: Literal["original", "preview", "raw"]
+) -> str:
+    """
+    Generate URL for dataset storage resources.
+
+    :param dataset_id: ID of the dataset
+    :type dataset_id: int
+    :param source_type: Type of source ("original", "preview", or "raw")
+    :type source_type: Literal["original", "preview", "raw"]
+    :return: Storage URL for dataset
+    :rtype: str
+    """
+    return get_storage_url("dataset", dataset_id, source_type)
+
+
+def get_project_storage_url(
+    project_id: int, source_type: Literal["original", "preview", "raw"]
+) -> str:
+    """
+    Generate URL for project storage resources.
+
+    :param project_id: ID of the project
+    :type project_id: int
+    :param source_type: Type of source ("original", "preview", or "raw")
+    :type source_type: Literal["original", "preview", "raw"]
+    :return: Storage URL for project
+    :rtype: str
+    """
+    return get_storage_url("project", project_id, source_type)
+
+
+def get_file_storage_url(file_id: int) -> str:
+    """
+    Generate URL for file storage resources (raw files).
+
+    :param file_id: ID of the file
+    :type file_id: int
+    :return: Storage URL for file
+    :rtype: str
+    """
+    return get_storage_url("file-storage", file_id, "raw")
+
+
 def get_preview_link(title="preview"):
     return (
         f'<a href="javascript:;">{title}<i class="zmdi zmdi-cast" style="margin-left: 5px"></i></a>'

supervisely/annotation/annotation.py

@@ -26,6 +26,7 @@ from supervisely.geometry.bitmap import Bitmap
 from supervisely.geometry.geometry import Geometry
 from supervisely.geometry.image_rotator import ImageRotator
 from supervisely.geometry.multichannel_bitmap import MultichannelBitmap
+from supervisely.geometry.oriented_bbox import OrientedBBox
 from supervisely.geometry.polygon import Polygon
 from supervisely.geometry.rectangle import Rectangle
 from supervisely.imaging import font as sly_font
@@ -551,7 +552,7 @@ class Annotation:
         :return: list of the Label class objects
         """
         for label in labels:
-            if self.img_size.count(None) == 0:
+            if self.img_size.count(None) == 0 and not isinstance(label.geometry, OrientedBBox):
                 # image has resolution in DB
                 canvas_rect = Rectangle.from_size(self.img_size)
                 try:
@@ -566,6 +567,7 @@ class Annotation:
             else:
                 # image was uploaded by link and does not have resolution in DB
                 # add label without normalization and validation
+                # OrientedBBox geometries can be outside of image bounds
                 dest.append(label)
 
     def add_label(self, label: Label) -> Annotation:
@@ -1417,7 +1419,7 @@ class Annotation:
         if draw_tags is True:
             tags_font = self._get_font()
         for label in self._labels:
-            if not fill_rectangles and isinstance(label.geometry, Rectangle):
+            if not fill_rectangles and isinstance(label.geometry, (Rectangle, OrientedBBox)):
                 label.draw_contour(
                     bitmap,
                     color=color,
@@ -2962,6 +2964,8 @@ class Annotation:
         for label in data[AnnotationJsonFields.LABELS]:
             if label[LabelJsonFields.GEOMETRY_TYPE] == Rectangle.geometry_name():
                 label = Rectangle._to_pixel_coordinate_system_json(label, image_size)
+            elif label[LabelJsonFields.GEOMETRY_TYPE] == OrientedBBox.geometry_name():
+                label = OrientedBBox._to_pixel_coordinate_system_json(label, image_size)
             else:
                 label = Geometry._to_pixel_coordinate_system_json(label, image_size)
             new_labels.append(label)
@@ -2988,6 +2992,8 @@ class Annotation:
         for label in data[AnnotationJsonFields.LABELS]:
             if label[LabelJsonFields.GEOMETRY_TYPE] == Rectangle.geometry_name():
                 label = Rectangle._to_subpixel_coordinate_system_json(label)
+            elif label[LabelJsonFields.GEOMETRY_TYPE] == OrientedBBox.geometry_name():
+                label = OrientedBBox._to_subpixel_coordinate_system_json(label)
             else:
                 label = Geometry._to_subpixel_coordinate_system_json(label)
             new_labels.append(label)

supervisely/annotation/json_geometries_map.py

@@ -1,21 +1,22 @@
 # coding: utf-8
+from supervisely.geometry.alpha_mask import AlphaMask
+from supervisely.geometry.any_geometry import AnyGeometry
 from supervisely.geometry.bitmap import Bitmap
-from supervisely.geometry.mask_3d import Mask3D
+from supervisely.geometry.closed_surface_mesh import ClosedSurfaceMesh
 from supervisely.geometry.cuboid import Cuboid
+from supervisely.geometry.cuboid_2d import Cuboid2d
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.geometry.graph import GraphNodes
+from supervisely.geometry.mask_3d import Mask3D
+from supervisely.geometry.multichannel_bitmap import MultichannelBitmap
+from supervisely.geometry.oriented_bbox import OrientedBBox
 from supervisely.geometry.point import Point
+from supervisely.geometry.point_3d import Point3d
+from supervisely.geometry.pointcloud import Pointcloud
 from supervisely.geometry.polygon import Polygon
 from supervisely.geometry.polyline import Polyline
+from supervisely.geometry.polyline_3d import Polyline3D
 from supervisely.geometry.rectangle import Rectangle
-from supervisely.geometry.graph import GraphNodes
-from supervisely.geometry.any_geometry import AnyGeometry
-from supervisely.geometry.cuboid_3d import Cuboid3d
-from supervisely.geometry.pointcloud import Pointcloud
-from supervisely.geometry.point_3d import Point3d
-from supervisely.geometry.multichannel_bitmap import MultichannelBitmap
-from supervisely.geometry.closed_surface_mesh import ClosedSurfaceMesh
-from supervisely.geometry.alpha_mask import AlphaMask
-from supervisely.geometry.cuboid_2d import Cuboid2d
-
 
 _INPUT_GEOMETRIES = [
     Bitmap,
@@ -34,6 +35,8 @@ _INPUT_GEOMETRIES = [
     ClosedSurfaceMesh,
     AlphaMask,
     Cuboid2d,
+    Polyline3D,
+    OrientedBBox,
 ]
 _JSON_SHAPE_TO_GEOMETRY_TYPE = {
     geometry.geometry_name(): geometry for geometry in _INPUT_GEOMETRIES

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/api/annotation_api.py

@@ -869,9 +869,12 @@ class AnnotationApi(ModuleApi):
             )
 
         # use context to avoid redundant API calls
-        dataset_id = self._api.image.get_info_by_id(
-            img_ids[0], force_metadata_for_links=False
-        ).dataset_id
+        image_info = self._api.image.get_info_by_id(img_ids[0], force_metadata_for_links=False)
+        if image_info is None:
+            raise RuntimeError(
+                f"Cannot get dataset ID from image info. Image with ID={img_ids[0]} not found."
+            )
+        dataset_id = image_info.dataset_id
         context = self._api.optimization_context
         context_dataset_id = context.get("dataset_id")
         project_id = context.get("project_id")
@@ -1312,14 +1315,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.