supervisely 6.73.410__py3-none-any.whl → 6.73.470__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,
@@ -112,7 +128,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 +341,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/json_geometries_map.py

@@ -15,6 +15,7 @@ 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
+from supervisely.geometry.polyline_3d import Polyline3D
 
 
 _INPUT_GEOMETRIES = [
@@ -34,6 +35,7 @@ _INPUT_GEOMETRIES = [
     ClosedSurfaceMesh,
     AlphaMask,
     Cuboid2d,
+    Polyline3D,
 ]
 _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

@@ -865,7 +865,7 @@ class AnnotationApi(ModuleApi):
             return
         if len(img_ids) != len(anns):
             raise RuntimeError(
-                'Can not match "img_ids" and "anns" lists, len(img_ids) != len(anns)'
+                f'Lists "img_ids" and "anns" have different lengths: {len(img_ids)} != {len(anns)}.'
             )
 
         # use context to avoid redundant API calls
@@ -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/api/api.py

@@ -10,6 +10,7 @@ import glob
 import json
 import os
 import shutil
+import threading
 from logging import Logger
 from pathlib import Path
 from typing import (
@@ -392,13 +393,15 @@ class Api:
             else not self.server_address.startswith("https://")
         )
 
-        if check_instance_version:
-            self._check_version(None if check_instance_version is True else check_instance_version)
-
         self.async_httpx_client: httpx.AsyncClient = None
         self.httpx_client: httpx.Client = None
         self._semaphore = None
         self._instance_version = None
+        self._version_check_completed = False
+        self._version_check_lock = threading.Lock()
+
+        if check_instance_version:
+            self._check_version(None if check_instance_version is True else check_instance_version)
 
     @classmethod
     def normalize_server_address(cls, server_address: str) -> str:
@@ -600,38 +603,49 @@ class Api:
         :type version: Optional[str], e.g. "6.9.13"
         """
 
-        # Since it's a informational message, we don't raise an exception if the check fails
-        # in any case, we don't want to interrupt the user's workflow.
-        try:
-            check_result = self.is_version_supported(version)
-            if check_result is None:
+        # Thread-safe one-time check with double-checked locking pattern
+        if self._version_check_completed:
+            return
+
+        with self._version_check_lock:
+            # Double-check inside the lock
+            if self._version_check_completed:
+                return
+
+            self._version_check_completed = True
+
+            # Since it's a informational message, we don't raise an exception if the check fails
+            # in any case, we don't want to interrupt the user's workflow.
+            try:
+                check_result = self.is_version_supported(version)
+                if check_result is None:
+                    logger.debug(
+                        "Failed to check if the instance version meets the minimum requirements "
+                        "of current SDK version. "
+                        "Ensure that the MINIMUM_INSTANCE_VERSION_FOR_SDK environment variable is set. "
+                        "Usually you can ignore this message, but if you're adding new features, "
+                        "which will require upgrade of the Supervisely instance, you should update "
+                        "it supervisely.__init__.py file."
+                    )
+                if check_result is False:
+                    message = (
+                        "The current version of the Supervisely instance is not supported by the SDK. "
+                        "Some features may not work correctly."
+                    )
+                    if not is_community():
+                        message += (
+                            " Please upgrade the Supervisely instance to the latest version (recommended) "
+                            "or downgrade the SDK to the version that supports the current instance (not recommended). "
+                            "Refer to this docs for more information: "
+                            "https://docs.supervisely.com/enterprise-edition/get-supervisely/upgrade "
+                            "Check out changelog for the latest version of Supervisely: "
+                            "https://app.supervisely.com/changelog"
+                        )
+                        logger.warning(message)
+            except Exception as e:
                 logger.debug(
-                    "Failed to check if the instance version meets the minimum requirements "
-                    "of current SDK version. "
-                    "Ensure that the MINIMUM_INSTANCE_VERSION_FOR_SDK environment variable is set. "
-                    "Usually you can ignore this message, but if you're adding new features, "
-                    "which will require upgrade of the Supervisely instance, you should update "
-                    "it supervisely.__init__.py file."
+                    f"Tried to check version compatibility between SDK and instance, but failed: {e}"
                 )
-            if check_result is False:
-                message = (
-                    "The current version of the Supervisely instance is not supported by the SDK. "
-                    "Some features may not work correctly."
-                )
-                if not is_community():
-                    message += (
-                        " Please upgrade the Supervisely instance to the latest version (recommended) "
-                        "or downgrade the SDK to the version that supports the current instance (not recommended). "
-                        "Refer to this docs for more information: "
-                        "https://docs.supervisely.com/enterprise-edition/get-supervisely/upgrade "
-                        "Check out changelog for the latest version of Supervisely: "
-                        "https://app.supervisely.com/changelog"
-                    )
-                    logger.warning(message)
-        except Exception as e:
-            logger.debug(
-                f"Tried to check version compatibility between SDK and instance, but failed: {e}"
-            )
 
     def post(
         self,
@@ -686,7 +700,8 @@ class Api:
                     )
 
                 if response.status_code != requests.codes.ok:  # pylint: disable=no-member
-                    self._check_version()
+                    if not self._version_check_completed:
+                        self._check_version()
                     Api._raise_for_status(response)
                 return response
             except requests.RequestException as exc:
@@ -723,6 +738,7 @@ class Api:
         retries: Optional[int] = None,
         stream: Optional[bool] = False,
         use_public_api: Optional[bool] = True,
+        data: Optional[Dict] = None,
     ) -> requests.Response:
         """
         Performs GET request to server with given parameters.
@@ -730,13 +746,15 @@ class Api:
         :param method:
         :type method: str
         :param params: Dictionary to send in the body of the :class:`Request`.
-        :type method: dict
+        :type params: dict
         :param retries: The number of attempts to connect to the server.
-        :type method: int, optional
+        :type retries: int, optional
         :param stream: Define, if you'd like to get the raw socket response from the server.
-        :type method: bool, optional
+        :type stream: bool, optional
         :param use_public_api:
-        :type method: bool, optional
+        :type use_public_api: bool, optional
+        :param data: Dictionary to send in the body of the :class:`Request`.
+        :type data: dict, optional
         :return: Response object
         :rtype: :class:`Response<Response>`
         """
@@ -756,7 +774,9 @@ class Api:
                 json_body = params
                 if type(params) is dict:
                     json_body = {**params, **self.additional_fields}
-                response = requests.get(url, params=json_body, headers=self.headers, stream=stream)
+                response = requests.get(
+                    url, params=json_body, data=data, headers=self.headers, stream=stream
+                )
 
                 if response.status_code != requests.codes.ok:  # pylint: disable=no-member
                     Api._raise_for_status(response)
@@ -1098,7 +1118,8 @@ class Api:
                     timeout=timeout,
                 )
                 if response.status_code != httpx.codes.OK:
-                    self._check_version()
+                    if not self._version_check_completed:
+                        self._check_version()
                     Api._raise_for_status_httpx(response)
                 return response
             except (httpx.RequestError, httpx.HTTPStatusError) as exc:
@@ -1314,7 +1335,8 @@ class Api:
                         httpx.codes.OK,
                         httpx.codes.PARTIAL_CONTENT,
                     ]:
-                        self._check_version()
+                        if not self._version_check_completed:
+                            self._check_version()
                         Api._raise_for_status_httpx(resp)
 
                     hhash = resp.headers.get("x-content-checksum-sha256", None)
@@ -1428,7 +1450,8 @@ class Api:
                     timeout=timeout,
                 )
                 if response.status_code != httpx.codes.OK:
-                    self._check_version()
+                    if not self._version_check_completed:
+                        self._check_version()
                     Api._raise_for_status_httpx(response)
                 return response
             except (httpx.RequestError, httpx.HTTPStatusError) as exc:
@@ -1569,7 +1592,8 @@ class Api:
                         httpx.codes.OK,
                         httpx.codes.PARTIAL_CONTENT,
                     ]:
-                        self._check_version()
+                        if not self._version_check_completed:
+                            self._check_version()
                         Api._raise_for_status_httpx(resp)
 
                     # received hash of the content to check integrity of the data stream