supervisely 6.73.355__py3-none-any.whl → 6.73.357__py3-none-any.whl

supervisely/api/api.py

@@ -45,6 +45,8 @@ import supervisely.api.image_api as image_api
 import supervisely.api.import_storage_api as import_stoarge_api
 import supervisely.api.issues_api as issues_api
 import supervisely.api.labeling_job_api as labeling_job_api
+import supervisely.api.labeling_queue_api as labeling_queue_api
+import supervisely.api.entities_collection_api as entities_collection_api
 import supervisely.api.neural_network_api as neural_network_api
 import supervisely.api.object_class_api as object_class_api
 import supervisely.api.plugin_api as plugin_api
@@ -353,6 +355,7 @@ class Api:
         self.role = role_api.RoleApi(self)
         self.user = user_api.UserApi(self)
         self.labeling_job = labeling_job_api.LabelingJobApi(self)
+        self.labeling_queue = labeling_queue_api.LabelingQueueApi(self)
         self.video = video_api.VideoApi(self)
         # self.project_class = project_class_api.ProjectClassApi(self)
         self.object_class = object_class_api.ObjectClassApi(self)
@@ -370,6 +373,7 @@ class Api:
         self.github = github_api.GithubApi(self)
         self.volume = volume_api.VolumeApi(self)
         self.issues = issues_api.IssuesApi(self)
+        self.entities_collection = entities_collection_api.EntitiesCollectionApi(self)
 
         self.retry_count = retry_count
         self.retry_sleep_sec = retry_sleep_sec

supervisely/api/app_api.py

@@ -1446,7 +1446,7 @@ class AppApi(TaskApi):
         return response.json()
 
     def get_ecosystem_module_info(
-        self, module_id: int, version: Optional[str] = None
+        self, module_id: int = None, version: Optional[str] = None, slug: Optional[str] = None
     ) -> ModuleInfo:
         """Returns ModuleInfo object by module id and version.
 
@@ -1454,6 +1454,10 @@ class AppApi(TaskApi):
         :type module_id: int
         :param version: version of the module, e.g. "v1.0.0"
         :type version: Optional[str]
+        :param slug: slug of the module, e.g. "supervisely-ecosystem/export-to-supervisely-format"
+        :type slug: Optional[str]
+        :raises ValueError: if both module_id and slug are None
+        :raises ValueError: if both module_id and slug are provided
         :return: ModuleInfo object
         :rtype: ModuleInfo
         :Usage example:
@@ -1473,7 +1477,13 @@ class AppApi(TaskApi):
             module_id = 81
             module_info = api.app.get_ecosystem_module_info(module_id)
         """
-        data = {ApiField.ID: module_id}
+        if module_id is None and slug is None:
+            raise ValueError("Either module_id or slug must be provided")
+        if module_id is not None:
+            data = {ApiField.ID: module_id}
+        else:
+            data = {ApiField.SLUG: slug}
+
         if version is not None:
             data[ApiField.VERSION] = version
         response = self._api.post("ecosystem.info", data)

supervisely/api/constants.py

@@ -1,3 +1,24 @@
 # coding: utf-8
 
 DOWNLOAD_BATCH_SIZE = None
+
+# for Video Labeling Toolbox
+PLAYBACK_RATE_POSSIBLE_VALUES = [
+    0.1,
+    0.3,
+    0.5,
+    0.6,
+    0.7,
+    0.8,
+    0.9,
+    1,
+    1.1,
+    1.2,
+    1.3,
+    1.5,
+    2,
+    4,
+    8,
+    16,
+    32,
+]

supervisely/api/entities_collection_api.py

@@ -0,0 +1,304 @@
+# coding: utf-8
+"""create or manipulate already existing Entities Collection in Supervisely"""
+
+# docs
+from __future__ import annotations
+
+from typing import Dict, List, NamedTuple, Optional
+
+from supervisely.api.module_api import (
+    ApiField,
+    ModuleApi,
+    RemoveableModuleApi,
+    UpdateableModule,
+)
+from supervisely.sly_logger import logger
+
+
+class EntitiesCollectionInfo(NamedTuple):
+    id: int
+    name: str
+    team_id: int
+    project_id: int
+    description: str
+    created_at: str
+    updated_at: str
+
+
+class EntitiesCollectionApi(UpdateableModule, RemoveableModuleApi):
+    """
+    API for working with Entities Collection. :class:`EntitiesCollectionApi<EntitiesCollectionApi>` object is immutable.
+
+    :param api: API connection to the server.
+    :type api: Api
+    :Usage example:
+
+     .. code-block:: python
+
+        import os
+        from dotenv import load_dotenv
+
+        import supervisely as sly
+
+        # Load secrets and create API object from .env file (recommended)
+        # Learn more here: https://developer.supervisely.com/getting-started/basics-of-authentication
+        if sly.is_development():
+            load_dotenv(os.path.expanduser("~/supervisely.env"))
+        api = sly.Api.from_env()
+
+        # Pass values into the API constructor (optional, not recommended)
+        # api = sly.Api(server_address="https://app.supervise.ly", token="4r47N...xaTatb")
+
+        collection = api.entities_collection.get_list(9) # api usage example
+    """
+
+    @staticmethod
+    def info_sequence():
+        """
+        NamedTuple EntitiesCollectionInfo information about Entities Collection.
+
+        :Example:
+
+         .. code-block:: python
+
+             EntitiesCollectionInfo(
+                id=2,
+                name='Enitites Collections #1',
+                team_id=4,
+                project_id=58,
+                description='',
+                created_at='2020-04-08T15:10:12.618Z',
+                updated_at='2020-04-08T15:10:19.833Z',
+            )
+        """
+        return [
+            ApiField.ID,
+            ApiField.NAME,
+            ApiField.TEAM_ID,
+            ApiField.PROJECT_ID,
+            ApiField.DESCRIPTION,
+            ApiField.CREATED_AT,
+            ApiField.UPDATED_AT,
+        ]
+
+    @staticmethod
+    def info_tuple_name():
+        """
+        NamedTuple name - **EntitiesCollectionInfo**.
+        """
+        return "EntitiesCollectionInfo"
+
+    def __init__(self, api):
+        ModuleApi.__init__(self, api)
+
+    def create(
+        self, project_id: int, name: str, description: Optional[str] = None
+    ) -> EntitiesCollectionInfo:
+        """
+        Creates Entities Collections.
+
+        :param project_id: Project ID in Supervisely.
+        :type project_id: int
+        :param name: Entities Collection name in Supervisely.
+        :type name: str
+        :param description: Entities Collection description.
+        :type description: str
+        :return: Information about new Entities Collection
+        :rtype: :class:`EntitiesCollectionInfo`
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            user_name = 'Collection #1'
+            project_id = 602
+            new_collection = api.entities_collection.create(name, project_id)
+            print(new_collection)
+        """
+
+        data = {ApiField.NAME: name, ApiField.PROJECT_ID: project_id}
+        if description is not None:
+            data[ApiField.DESCRIPTION] = description
+        response = self._api.post("entities-collections.add", data)
+        return self._convert_json_info(response.json())
+
+    def get_list(
+        self,
+        project_id: int,
+        filters: Optional[List[Dict[str, str]]] = None,
+    ) -> List[EntitiesCollectionInfo]:
+        """
+        Get list of information about Entities Collection for the given project.
+
+        :param project_id: Project ID in Supervisely.
+        :type project_id: int, optional
+        :return: List of information about Entities Collections.
+        :rtype: :class:`List[EntitiesCollectionInfo]`
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            collections = api.entities_collection.get_list(4)
+        """
+        if filters is None:
+            filters = []
+        return self.get_list_all_pages(
+            "entities-collections.list",
+            {ApiField.PROJECT_ID: project_id, ApiField.FILTER: filters},
+        )
+
+    def get_info_by_id(self, id: int) -> EntitiesCollectionInfo:
+        """
+        Get information about Entities Collection with given ID.
+
+        :param id: Entities Collection ID in Supervisely.
+        :type id: int
+        :return: Information about Entities Collection.
+        :rtype: :class:`EntitiesCollectionInfo`
+        :Usage example:
+
+            .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            collection = api.entities_collection.get_info_by_id(2)
+            print(collection)
+            # Output:
+            # {
+            #     "id": 1,
+            #     "teamId": 1,
+            #     "projectId": 1,
+            #     "name": "ds",
+            #     "description": "",
+            #     "createdAt": "2018-08-21T14:25:56.140Z",
+            #     "updatedAt": "2018-08-21T14:25:56.140Z"
+            # }
+        """
+        return self._get_info_by_id(id, "entities-collections.info")
+
+    def _get_update_method(self):
+        """ """
+        return "entities-collections.editInfo"
+
+    def _remove_api_method_name(self):
+        """ """
+        return "entities-collections.remove"
+
+    def _get_update_method(self):
+        """ """
+        return "entities-collections.editInfo"
+
+    def add_items(self, id: int, items: List[int]) -> List[Dict[str, int]]:
+        """
+        Add items to Entities Collection.
+
+        :param id: Entities Collection ID in Supervisely.
+        :type id: int
+        :param items: List of item IDs in Supervisely.
+        :type items: List[int]
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            collection_id = 2
+            item_ids = [525, 526]
+            new_items = api.entities_collection.add_items(collection_id, item_ids)
+            print(new_items)
+            # Output: [
+            #   {"id": 1, "entityId": 525, 'createdAt': '2025-04-10T08:49:41.852Z'},
+            #   {"id": 2, "entityId": 526, 'createdAt': '2025-04-10T08:49:41.852Z'}
+            ]
+        """
+        data = {ApiField.COLLECTION_ID: id, ApiField.ENTITY_IDS: items}
+        response = self._api.post("entities-collections.items.bulk.add", data)
+        response = response.json()
+        if len(response["missing"]) > 0:
+            raise RuntimeError(
+                f"Failed to add items to Entities Collection. IDs: {response['missing']}. "
+            )
+        return response["items"]
+
+    def get_items(self, id: int, project_id: Optional[int] = None) -> List[int]:
+        """
+        Get items from Entities Collection.
+
+        :param id: Entities Collection ID in Supervisely.
+        :type id: int
+        :param project_id: Project ID in Supervisely.
+        :type project_id: int, optional
+        :return: List of item IDs in Supervisely.
+        :rtype: List[int]
+        :raises RuntimeError: If Entities Collection with given ID not found.
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            collection_id = 2
+            project_id = 4
+            item_ids = api.entities_collection.get_items(collection_id, project_id)
+            print(item_ids)
+        """
+        if project_id is None:
+            info = self.get_info_by_id(id)
+            if info is None:
+                raise RuntimeError(f"Entities Collection with id={id} not found.")
+            project_id = info.project_id
+
+        return self._api.image.get_list(project_id=project_id, entities_collection_id=id)
+
+    def remove_items(self, id: int, items: List[int]) -> List[Dict[str, int]]:
+        """
+        Remove items from Entities Collection.
+
+        :param id: Entities Collection ID in Supervisely.
+        :type id: int
+        :param items: List of item IDs in Supervisely.
+        :type items: List[int]
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+            api = sly.Api.from_env()
+
+            collection_id = 2
+            item_ids = [525, 526, 527]
+            removed_items = api.entities_collection.remove_items(collection_id, item_ids)
+            # print(removed_items)
+            # Output: [{"id": 1, "entityId": 525}, {"id": 2, "entityId": 526}]
+        """
+        data = {ApiField.COLLECTION_ID: id, ApiField.ENTITY_IDS: items}
+        response = self._api.post("entities-collections.items.bulk.remove", data)
+        response = response.json()
+        if len(response["missing"]) > 0:
+            logger.warning(
+                f"Failed to remove items from Entities Collection. IDs: {response['missing']}. "
+            )
+        return response["items"]

supervisely/api/image_api.py

@@ -601,6 +601,7 @@ class ImageApi(RemoveableBulkModuleApi):
         only_labelled: Optional[bool] = False,
         fields: Optional[List[str]] = None,
         recursive: Optional[bool] = False,
+        entities_collection_id: Optional[int] = None,
     ) -> List[ImageInfo]:
         """
         List of Images in the given :class:`Dataset<supervisely.project.project.Dataset>`.
@@ -627,6 +628,8 @@ class ImageApi(RemoveableBulkModuleApi):
         :type fields: List[str], optional
         :param recursive: If True, returns all images from dataset recursively (including images in nested datasets).
         :type recursive: bool, optional
+        :param entities_collection_id: :class:`EntitiesCollection<supervisely.api.entities_collection_api.EntitiesCollectionApi>` ID to which the images belong. Can be used to filter images by specific entities collection.
+        :type entities_collection_id: int, optional
         :return: Objects with image information from Supervisely.
         :rtype: :class:`List[ImageInfo]<ImageInfo>`
         :Usage example:
@@ -700,6 +703,18 @@ class ImageApi(RemoveableBulkModuleApi):
                     },
                 }
             ]
+        if entities_collection_id is not None:
+            if ApiField.FILTERS not in data:
+                data[ApiField.FILTERS] = []
+            data[ApiField.FILTERS].append(
+                {
+                    "type": "entities_collection",
+                    "data": {
+                        ApiField.COLLECTION_ID: entities_collection_id,
+                        ApiField.INCLUDE: True,
+                    },
+                }
+            )
         if fields is not None:
             data[ApiField.FIELDS] = fields
         return self.get_list_all_pages(

supervisely/api/labeling_job_api.py

@@ -88,6 +88,7 @@ class LabelingJobInfo(NamedTuple):
     include_images_with_tags: list
     exclude_images_with_tags: list
     entities: list
+    priority: int
 
 
 class LabelingJobApi(RemoveableBulkModuleApi, ModuleWithStatus):
@@ -179,7 +180,8 @@ class LabelingJobApi(RemoveableBulkModuleApi, ModuleWithStatus):
                              filter_images_by_tags=[],
                              include_images_with_tags=[],
                              exclude_images_with_tags=[],
-                             entities=None)
+                             entities=None,
+                             priority=2)
         """
         return [
             ApiField.ID,
@@ -220,6 +222,7 @@ class LabelingJobApi(RemoveableBulkModuleApi, ModuleWithStatus):
             ApiField.INCLUDE_IMAGES_WITH_TAGS,
             ApiField.EXCLUDE_IMAGES_WITH_TAGS,
             ApiField.ENTITIES,
+            ApiField.PRIORITY,
         ]
 
     @staticmethod

supervisely/api/labeling_queue_api.py

@@ -0,0 +1,735 @@
+# coding: utf-8
+"""create or manipulate already existing labeling queues"""
+
+# docs
+from __future__ import annotations
+
+from typing import Dict, List, Literal, NamedTuple, Optional, Union
+
+from supervisely.api.constants import PLAYBACK_RATE_POSSIBLE_VALUES
+from supervisely.api.labeling_job_api import LabelingJobApi
+from supervisely.api.module_api import (
+    ApiField,
+    ModuleApi,
+    ModuleWithStatus,
+    RemoveableBulkModuleApi,
+)
+from supervisely.project.project_meta import ProjectMeta
+from supervisely.project.project_type import ProjectType
+
+
+class LabelingQueueInfo(NamedTuple):
+    id: int
+    name: str
+    team_id: int
+    project_id: int
+    dataset_id: int
+    created_by_id: int
+    labelers: list
+    reviewers: list
+    created_at: str
+    finished_at: str
+    status: str
+    jobs: list
+    entities_count: int
+    accepted_count: int
+    annotated_count: int
+    in_progress_count: int
+    pending_count: int
+    meta: dict
+
+
+class LabelingQueueApi(RemoveableBulkModuleApi, ModuleWithStatus):
+    """
+    API for working with Labeling Queues. :class:`LabelingQueueApi<LabelingQueueApi>` object is immutable.
+
+    :param api: API connection to the server.
+    :type api: Api
+    :Usage example:
+
+     .. code-block:: python
+
+        import os
+        from dotenv import load_dotenv
+
+        import supervisely as sly
+
+        # Load secrets and create API object from .env file (recommended)
+        # Learn more here: https://developer.supervisely.com/getting-started/basics-of-authentication
+        if sly.is_development():
+            load_dotenv(os.path.expanduser("~/supervisely.env"))
+        api = sly.Api.from_env()
+
+        # Pass values into the API constructor (optional, not recommended)
+        # api = sly.Api(server_address="https://app.supervise.ly", token="4r47N...xaTatb")
+
+        queue = api.labeling_queues.get_info_by_id(2) # api usage example
+    """
+
+    @staticmethod
+    def info_sequence():
+        """
+        NamedTuple LabelingQueueInfo information about Labeling Queue.
+
+        :Example:
+
+         .. code-block:: python
+
+            LabelingQueueInfo(
+                id=2,
+                name='Annotation Queue (#1)',
+                team_id=4,
+                project_id=58,
+                dataset_id=54,
+                created_by_id=4,
+                labelers=[4],
+                reviewers=[4],
+                created_at='2020-04-08T15:10:12.618Z',
+                finished_at='2020-04-08T15:13:39.788Z',
+                status='completed',
+                jobs=[283, 282, 281],
+                entities_count=3,
+                accepted_count=2,
+                annotated_count=3,
+                in_progress_count=2,
+                pending_count=1,
+                meta={}
+            )
+        """
+        return [
+            ApiField.ID,
+            ApiField.NAME,
+            ApiField.TEAM_ID,
+            ApiField.PROJECT_ID,
+            ApiField.DATASET_ID,
+            ApiField.CREATED_BY_ID,
+            ApiField.LABELERS,
+            ApiField.REVIEWERS,
+            ApiField.CREATED_AT,
+            ApiField.FINISHED_AT,
+            ApiField.STATUS,
+            ApiField.JOBS,
+            ApiField.ENTITIES_COUNT,
+            ApiField.ACCEPTED_COUNT,
+            ApiField.ANNOTATED_COUNT,
+            ApiField.IN_PROGRESS_COUNT,
+            ApiField.PENDING_COUNT,
+            ApiField.META,
+        ]
+
+    @staticmethod
+    def info_tuple_name():
+        """
+        NamedTuple name - **LabelingQueueInfo**.
+        """
+        return "LabelingQueueInfo"
+
+    def _convert_json_info(self, info: Dict, skip_missing: Optional[bool] = True):
+        """ """
+
+        def _get_value(dict, field_name, skip_missing):
+            if skip_missing is True:
+                return dict.get(field_name, None)
+            else:
+                return dict[field_name]
+
+        def _get_ids(data, skip_missing):
+            if skip_missing is True:
+                return [job.get(ApiField.ID, None) for job in data]
+            else:
+                return [job[ApiField.ID] for job in data]
+
+        if info is None:
+            return None
+        else:
+            field_values = []
+            for field_name in self.info_sequence():
+                if type(field_name) is str:
+                    if field_name in [ApiField.JOBS, ApiField.LABELERS, ApiField.REVIEWERS]:
+                        field_values.append(_get_ids(info[field_name], skip_missing))
+                        continue
+                    else:
+                        field_values.append(_get_value(info, field_name, skip_missing))
+                elif type(field_name) is tuple:
+                    value = None
+                    for sub_name in field_name[0]:
+                        if value is None:
+                            value = _get_value(info, sub_name, skip_missing)
+                        else:
+                            value = _get_value(value, sub_name, skip_missing)
+                    field_values.append(value)
+                else:
+                    raise RuntimeError("Can not parse field {!r}".format(field_name))
+            res = self.InfoType(*field_values)
+            return LabelingQueueInfo(**res._asdict())
+
+    def _check_membership(self, ids: List[int], team_id: int) -> None:
+        """Check if user is a member of the team in which the Labeling Queue is created."""
+        for user_id in ids:
+            memberships = self._api.user.get_teams(user_id)
+            team_ids = [team.id for team in memberships]
+            if team_id not in team_ids:
+                raise RuntimeError(
+                    f"User with id {user_id} is not a member of the team with id {team_id}"
+                )
+
+    def create(
+        self,
+        name: str,
+        user_ids: List[int],
+        reviewer_ids: List[int],
+        dataset_id: Optional[int] = None,
+        collection_id: Optional[int] = None,
+        readme: Optional[str] = None,
+        classes_to_label: Optional[List[str]] = None,
+        objects_limit_per_image: Optional[int] = None,
+        tags_to_label: Optional[List[str]] = None,
+        tags_limit_per_image: Optional[int] = None,
+        include_images_with_tags: Optional[List[str]] = None,
+        exclude_images_with_tags: Optional[List[str]] = None,
+        images_range: Optional[List[int, int]] = None,
+        reviewer_id: Optional[int] = None,
+        images_ids: Optional[List[int]] = None,
+        dynamic_classes: Optional[bool] = False,
+        dynamic_tags: Optional[bool] = False,
+        disable_confirm: Optional[bool] = None,
+        disable_submit: Optional[bool] = None,
+        toolbox_settings: Optional[Dict] = None,
+        hide_figure_author: Optional[bool] = False,
+        allow_review_own_annotations: Optional[bool] = False,
+        skip_complete_job_on_empty: Optional[bool] = False,
+    ) -> int:
+        """
+        Creates Labeling Queue and assigns given Users to it.
+
+        :param name: Labeling Queue name in Supervisely.
+        :type name: str
+        :param dataset_id: Dataset ID in Supervisely.
+        :type dataset_id: int
+        :param collection_id: Entities Collection ID in Supervisely.
+        :type collection_id: int, optional
+        :param user_ids: User IDs in Supervisely to assign Users as labelers to Labeling Queue.
+        :type user_ids: List[int]
+        :param readme: Additional information about Labeling Queue.
+        :type readme: str, optional
+        :param description: Description of Labeling Queue.
+        :type description: str, optional
+        :param classes_to_label: List of classes to label in Dataset.
+        :type classes_to_label: List[str], optional
+        :param objects_limit_per_image: Limit the number of objects that the labeler can create on each image.
+        :type objects_limit_per_image: int, optional
+        :param tags_to_label: List of tags to label in Dataset.
+        :type tags_to_label: List[str], optional
+        :param tags_limit_per_image: Limit the number of tags that the labeler can create on each image.
+        :type tags_limit_per_image: int, optional
+        :param include_images_with_tags: Include images with given tags for processing by labeler.
+        :type include_images_with_tags: List[str], optional
+        :param exclude_images_with_tags: Exclude images with given tags for processing by labeler.
+        :type exclude_images_with_tags: List[str], optional
+        :param images_range: Limit number of images to be labeled for each labeler.
+        :type images_range: List[int, int], optional
+        :param reviewer_id: User ID in Supervisely to assign User as Reviewer to Labeling Queue.
+        :type reviewer_id: int, optional
+        :param images_ids: List of images ids to label in dataset
+        :type images_ids: List[int], optional
+        :param dynamic_classes: If True, classes created after creating the queue will be available for annotators
+        :type dynamic_classes: bool, optional
+        :param dynamic_tags: If True, tags created after creating the queue will be available for annotators
+        :type dynamic_tags: bool, optional
+        :param disable_confirm: If True, the Confirm button will be disabled in the labeling tool. It will remain disabled until the next API call sets the parameter to False, re-enabling the button.
+        :type disable_confirm: bool, optional
+        :param disable_submit: If True, the Submit button will be disabled in the labeling tool. It will remain disabled until the next API call sets the parameter to False, re-enabling the button.
+        :type disable_submit: bool, optional
+        :param toolbox_settings: Settings for the labeling tool. Only video projects are supported.
+        :type toolbox_settings: Dict, optional
+        :return: Labeling Queue ID in Supervisely.
+        :rtype: int
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            user_name = 'alex'
+            dataset_id = 602
+            new_labeling_queue_id = api.labeling_queue.create(
+                user_name,
+                dataset_id,
+                user_ids=[111, 222],
+                readme='Readmy text',
+                description='Work for labelers',
+                objects_limit_per_image=5,
+                tags_limit_per_image=3
+            )
+            print(new_labeling_queue_id)
+
+            # >>> 2
+
+            # Create video labeling job with toolbox settings
+
+            user_id = 4
+            dataset_id = 277
+            video_id = 24897
+            toolbox_settings = {"playbackRate": 32, "skipFramesSize": 15, "showVideoTime": True}
+
+            new_labeling_queue_id = api.labeling_queue.create(
+                name="Labeling Queue name",
+                dataset_id=dataset_id,
+                user_ids=[user_id],
+                readme="Labeling Queue readme",
+                description="Some description",
+                classes_to_label=["car", "animal"],
+                tags_to_label=["animal_age_group"],
+                images_ids=[video_id],
+                toolbox_settings=toolbox_settings,
+            )
+            print(new_labeling_queue_id)
+
+            # >>> 3
+        """
+        if dataset_id is None and collection_id is None:
+            raise RuntimeError("Either dataset_id or collection_id must be provided")
+        if classes_to_label is None:
+            classes_to_label = []
+        if tags_to_label is None:
+            tags_to_label = []
+
+        filter_images_by_tags = []
+        if include_images_with_tags is not None:
+            for tag_name in include_images_with_tags:
+                filter_images_by_tags.append({"name": tag_name, "positive": True})
+
+        if exclude_images_with_tags is not None:
+            for tag_name in exclude_images_with_tags:
+                filter_images_by_tags.append({"name": tag_name, "positive": False})
+
+        if objects_limit_per_image is None:
+            objects_limit_per_image = 0
+
+        if tags_limit_per_image is None:
+            tags_limit_per_image = 0
+
+        meta = {
+            "classes": classes_to_label,
+            "projectTags": tags_to_label,
+            "imageTags": filter_images_by_tags,
+            "imageFiguresLimit": objects_limit_per_image,
+            "imageTagsLimit": tags_limit_per_image,
+            "dynamicClasses": dynamic_classes,
+            "dynamicTags": dynamic_tags,
+            "hideFigureAuthor": hide_figure_author,
+        }
+        if images_ids is not None:
+            meta["entityIds"] = images_ids
+
+        if toolbox_settings is not None:
+            if dataset_id is not None:
+                dataset_info = self._api.dataset.get_info_by_id(dataset_id)
+                project_id = dataset_info.project_id
+            else:
+                collection_info = self._api.entities_collection.get_info_by_id(collection_id)
+                project_id = collection_info.project_id
+            project_info = self._api.project.get_info_by_id(project_id)
+            project_type = project_info.type
+            if project_type == ProjectType.VIDEOS.value:
+                playback_rate = toolbox_settings.get("playbackRate", None)
+                if playback_rate is not None:
+                    if playback_rate not in PLAYBACK_RATE_POSSIBLE_VALUES:
+                        raise ValueError(
+                            f"'playbackRate' must be one of: '{','.join(PLAYBACK_RATE_POSSIBLE_VALUES)}'"
+                        )
+                meta["toolboxSettings"] = toolbox_settings
+
+        if disable_confirm is not None:
+            meta.update({"disableConfirm": disable_confirm})
+        if disable_submit is not None:
+            meta.update({"disableSubmit": disable_submit})
+
+        queue_meta = {}
+        if allow_review_own_annotations is True:
+            queue_meta["reviewOwnAnnotationsAvailable"] = True
+
+        if skip_complete_job_on_empty is True:
+            queue_meta["skipCompleteAnnotationJobOnEmpty"] = True
+
+        data = {
+            ApiField.NAME: name,
+            ApiField.USER_IDS: user_ids,
+            ApiField.REVIEWER_IDS: reviewer_ids,
+            ApiField.META: meta,
+        }
+        if dataset_id is not None:
+            data[ApiField.DATASET_ID] = dataset_id
+        if collection_id is not None:
+            data[ApiField.COLLECTION_ID] = collection_id
+
+        if len(queue_meta) > 0:
+            data[ApiField.QUEUE_META] = queue_meta
+
+        if readme is not None:
+            data[ApiField.README] = str(readme)
+
+        if images_range is not None and images_range != (None, None):
+            if len(images_range) != 2:
+                raise RuntimeError("images_range has to contain 2 elements (start, end)")
+            images_range = {"start": images_range[0], "end": images_range[1]}
+            data[ApiField.META]["range"] = images_range
+
+        if reviewer_id is not None:
+            data[ApiField.REVIEWER_ID] = reviewer_id
+
+        response = self._api.post("labeling-queues.add", data)
+        return response.json()["id"]  # {"success": true}
+
+    def get_list(
+        self,
+        team_id: int,
+        dataset_id: Optional[int] = None,
+        project_id: Optional[int] = None,
+        ids: Optional[List[int]] = None,
+        names: Optional[List[str]] = None,
+        show_disabled: Optional[bool] = False,
+    ) -> List[LabelingQueueInfo]:
+        """
+        Get list of information about Labeling Queues in the given Team.
+
+        :param team_id: Team ID in Supervisely.
+        :type team_id: int
+        :param dataset_id: Dataset ID in Supervisely.
+        :type dataset_id: int, optional
+        :param project_id: Project ID in Supervisely.
+        :type project_id: int, optional
+        :param ids: List of Labeling Queue IDs in Supervisely.
+        :type ids: List[int], optional
+        :param names: List of Labeling Queue names in Supervisely.
+        :type names: List[str], optional
+        :param show_disabled: Show disabled Labeling Queues.
+        :type show_disabled: bool, optional
+        :return: List of information about Labeling Queues. See :class:`info_sequence<info_sequence>`
+        :rtype: :class:`List[LabelingQueueInfo]`
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            label_jobs = api.labeling_queue.get_list(4)
+        """
+
+        filters = []
+        if project_id is not None:
+            filters.append({"field": ApiField.PROJECT_ID, "operator": "=", "value": project_id})
+        if dataset_id is not None:
+            filters.append({"field": ApiField.DATASET_ID, "operator": "=", "value": dataset_id})
+        if names is not None:
+            filters.append({"field": ApiField.NAME, "operator": "in", "value": names})
+        if ids is not None:
+            filters.append({"field": ApiField.ID, "operator": "in", "value": ids})
+        return self.get_list_all_pages(
+            "labeling-queues.list",
+            {ApiField.TEAM_ID: team_id, "showDisabled": show_disabled, ApiField.FILTER: filters},
+        )
+
+    def get_info_by_id(self, id: int) -> LabelingQueueInfo:
+        """
+        Get Labeling Queue information by ID.
+
+        :param id: Labeling Queue ID in Supervisely.
+        :type id: int
+        :return: Information about Labeling Queue. See :class:`info_sequence<info_sequence>`
+        :rtype: :class:`LabelingJobInfo`
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            label_job_info = api.labeling_queue.get_info_by_id(2)
+            print(label_job_info)
+            # Output: [
+            #     2,
+            #     "Annotation Queue (#1) (#1) (dataset_01)",
+            #     "",
+            #     "",
+            #     4,
+            #     8,
+            #     "First Workspace",
+            #     58,
+            #     "tutorial_project",
+            #     54,
+            #     "dataset_01",
+            #     4,
+            #     "anna",
+            #     4,
+            #     "anna",
+            #     4,
+            #     "anna",
+            #     "2020-04-08T15:10:12.618Z",
+            #     "2020-04-08T15:10:19.833Z",
+            #     "2020-04-08T15:13:39.788Z",
+            #     "completed",
+            #     false,
+            #     3,
+            #     0,
+            #     1,
+            #     2,
+            #     2,
+            #     [],
+            #     [],
+            #     [
+            #         1,
+            #         5
+            #     ],
+            #     null,
+            #     null,
+            #     [],
+            #     [],
+            #     [],
+            #     [
+            #         {
+            #             "reviewStatus": "rejected",
+            #             "id": 283,
+            #             "name": "image_03"
+            #         },
+            #         {
+            #             "reviewStatus": "accepted",
+            #             "id": 282,
+            #             "name": "image_02"
+            #         },
+            #         {
+            #             "reviewStatus": "accepted",
+            #             "id": 281,
+            #             "name": "image_01"
+            #         }
+            #     ]
+            # ]
+        """
+        return self._get_info_by_id(id, "labeling-queues.info")
+
+    def get_status(self, id: int) -> LabelingJobApi.Status:
+        """
+        Get status of Labeling Job with given ID.
+
+        :param id: Labeling job ID in Supervisely.
+        :type id: int
+        :return: Labeling Job Status
+        :rtype: :class:`Status<supervisely.api.labeling_job_api.LabelingJobApi.Status>`
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            job_status = api.labeling_queue.get_status(4)
+            print(job_status) # pending
+        """
+        status_str = self.get_info_by_id(id).status
+        return LabelingJobApi.Status(status_str)
+
+    def set_status(self, id: int, status: str) -> None:
+        """
+        Sets Labeling Queue status.
+
+        :param id: Labeling Queue ID in Supervisely.
+        :type id: int
+        :param status: New Labeling Queue status
+        :type status: str
+        :return: None
+        :rtype: :class:`NoneType`
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+            from supervisely.api.labeling_job_api.LabelingJobApi.Status import COMPLETED
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            api.labeling_queue.set_status(id=9, status="completed")
+        """
+        self._api.post("labeling-queues.set-status", {ApiField.ID: id, ApiField.STATUS: status})
+
+    def get_project_meta(self, id: int) -> ProjectMeta:
+        """
+        Returns project meta with classes and tags used in the labeling queue with given id.
+
+        :param id: Labeling Queue ID in Supervisely.
+        :type id: int
+        :return: Project meta of the labeling queue with given id.
+        :rtype: :class:`ProjectMeta`
+        """
+        queue_info = self.get_info_by_id(id)
+        project_meta_json = self._api.project.get_meta(queue_info.project_id, with_settings=True)
+        project_meta = ProjectMeta.from_json(project_meta_json)
+
+        jobs = [self._api.labeling_job.get_info_by_id(job_id) for job_id in queue_info.jobs]
+        job_classes = set()
+        job_tags = set()
+        for job in jobs:
+            job_classes.update(job.classes_to_label)
+            job_tags.update(job.tags_to_label)
+
+        filtered_classes = [
+            obj_cls for obj_cls in project_meta.obj_classes if obj_cls.name in job_classes
+        ]
+        filtered_tags = [
+            tag_meta for tag_meta in project_meta.tag_metas if tag_meta.name in job_tags
+        ]
+        queue_meta = ProjectMeta(obj_classes=filtered_classes, tag_metas=filtered_tags)
+        return queue_meta
+
+    def get_entities_all_pages(
+        self,
+        id: int,
+        collection_id: Optional[int] = None,
+        per_page: int = 25,
+        sort: str = "name",
+        sort_order: str = "asc",
+        status: Optional[Union[List, Literal["none", "done", "accepted", "null"]]] = None,
+        limit: int = None,
+        filter_by: List[Dict] = None,
+    ) -> Dict[str, Union[List[Dict], int]]:
+        """
+        Get list of all or limited quantity entities from the Supervisely server.
+
+        :param id: Labeling Queue ID in Supervisely.
+        :type id: int
+        :param collection_id: Collection ID in Supervisely.
+        :type collection_id: int, optional
+        :param per_page: Number of entities per page.
+        :type per_page: int, optional
+        :param sort: Sorting field.
+        :type sort: str, optional
+        :param sort_order: Sorting order.
+        :type sort_order: str, optional
+        :param status: Status of entities to filter.
+                        "null" - pending (in queue).
+                        "none" - annotating (not in queue),
+                        "done" - on review,
+                        "accepted" - accepted,
+        :type status: str or List[str], optional
+        :param limit: Limit the number of entities to return. If limit is None, all entities will be returned.
+        :type limit: int, optional
+        :param filter_by: Filter for entities.
+                       e.g. [{"field": "name", "operator": "in", "value": ["image_01", "image_02"]}]
+                        - field - field name to filter by ("id", "name", "reviewedAt")
+                        - operator - operator to use for filtering ("=", ">", "<", ">=", "<=")
+                        - value - value to filter by
+        :type filter_by: List[Dict], optional
+        :param return_first_response: Specify if return first response
+        :type return_first_response: bool, optional
+        """
+
+        method = "labeling-queues.stats.entities"
+        data = {
+            ApiField.ID: id,
+            ApiField.PAGE: 1,
+            ApiField.PER_PAGE: per_page,
+            ApiField.SORT: sort,
+            ApiField.SORT_ORDER: sort_order,
+        }
+        if collection_id is not None:
+            data[ApiField.FILTERS] = [
+                {
+                    "type": "entities_collection",
+                    "data": {ApiField.COLLECTION_ID: collection_id, ApiField.INCLUDE: True},
+                }
+            ]
+        if filter_by is not None:
+            data[ApiField.FILTER] = filter_by
+        if status is not None:
+            if type(status) is str:
+                status = [status]
+            status = [None if s == "null" else s.lower() for s in status]
+            data["entityStatus"] = status
+
+        first_response = self._api.post(method, data).json()
+        total = first_response["total"]
+        pages_count = int(total / per_page) + 1 if total % per_page != 0 else int(total / per_page)
+        if pages_count in [0, 1]:
+            return first_response
+
+        limit_exceeded = False
+        results = first_response["images"]
+        if limit is not None and len(results) > limit:
+            limit_exceeded = True
+
+        if (pages_count == 1 and len(results) == total) or limit_exceeded is True:
+            pass
+        else:
+            for page_idx in range(2, pages_count + 1):
+                temp_resp = self._api.post(method, {**data, "page": page_idx, "per_page": per_page})
+                temp_items = temp_resp.json()["images"]
+                results.extend(temp_items)
+                if limit is not None and len(results) > limit:
+                    limit_exceeded = True
+                    break
+
+            if len(results) != total and limit is None:
+                raise RuntimeError(
+                    "Method {!r}: error during pagination, some items are missed".format(method)
+                )
+
+        if limit is not None:
+            results = results[:limit]
+        return {"images": results, "total": total}
+
+    def get_entities_count_by_status(
+        self,
+        id: int,
+        status: Optional[Union[List, Literal["none", "done", "accepted", "null"]]] = None,
+        filter_by: List[Dict] = None,
+    ) -> int:
+        """
+        Get count of entities in the given Labeling Queue with given status.
+        :param id: Labeling Queue ID in Supervisely.
+        :type id: int
+        :param status: Status of entities to filter.
+                        "null" - pending (in queue).
+                        "none" - annotating (not in queue),
+                        "done" - on review,
+                        "accepted" - accepted,
+        :type status: str or List[str], optional
+        :param filter_by: Filter for entities.
+                       e.g. [{"field": "name", "operator": "in", "value": ["image_01", "image_02"]}]
+                        - field - field name to filter by ("id", "name", "reviewedAt")
+                        - operator - operator to use for filtering ("=", ">", "<", ">=", "<=")
+                        - value - value to filter by
+        :type filter_by: List[Dict], optional
+        :return: Count of entities in the Labeling Queue with given status.
+        :rtype: int
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            entities_count = api.labeling_queue.get_entities_count_by_status(4, status="none")
+            print(entities_count)
+            # Output: 3
+        """
+        return self.get_entities_all_pages(id, status=status, limit=1, filter_by=filter_by).get(
+            "total", 0
+        )

supervisely/api/module_api.py

@@ -637,6 +637,30 @@ class ApiField:
     """"""
     SOURCE_BLOB = "sourceBlob"
     """"""
+    JOBS = "jobs"
+    """"""
+    LABELERS = "labelers"
+    """"""
+    REVIEWERS = "reviewers"
+    """"""
+    REVIEWER_IDS = "reviewerIds"
+    """"""
+    ENTITIES_COUNT = "entitiesCount"
+    """"""
+    ACCEPTED_COUNT = "acceptedCount"
+    """"""
+    ANNOTATED_COUNT = "annotatedCount"
+    """"""
+    IN_PROGRESS_COUNT = "inProgressCount"
+    """"""
+    PENDING_COUNT = "pendingCount"
+    """"""
+    QUEUE_META = "queueMeta"
+    """"""
+    ENTITY_IDS = "entityIds"
+    """"""
+    COLLECTION_ID = "collectionId"
+    """"""
 
 
 def _get_single_item(items):

supervisely/volume_annotation/volume_figure.py

@@ -529,6 +529,7 @@ class VolumeFigure(VideoFigure):
         else:
             geometry_json = data[ApiField.GEOMETRY]
         geometry = shape.from_json(geometry_json)
+        geometry.sly_id = data.get(ID, None)
 
         key = uuid.UUID(data[KEY]) if KEY in data else uuid.uuid4()
 
@@ -636,10 +637,15 @@ class VolumeFigure(VideoFigure):
         """
         if isinstance(geometry_data, str):
             mask_3d = Mask3D.create_from_file(geometry_data)
-        if isinstance(geometry_data, ndarray):
+        elif isinstance(geometry_data, ndarray):
             mask_3d = Mask3D(geometry_data)
-        if isinstance(geometry_data, bytes):
+        elif isinstance(geometry_data, bytes):
             mask_3d = Mask3D.from_bytes(geometry_data)
+        else:
+            raise TypeError(
+                f"geometry_data must be str, ndarray, or bytes, but got {type(geometry_data)}"
+            )
+
         return cls(
             volume_object,
             mask_3d,

{supervisely-6.73.355.dist-info → supervisely-6.73.357.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.355
+Version: 6.73.357
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.355.dist-info → supervisely-6.73.357.dist-info}/RECORD

@@ -22,18 +22,20 @@ supervisely/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/api/advanced_api.py,sha256=Nd5cCnHFWc3PSUrCtENxTGtDjS37_lCHXsgXvUI3Ti8,2054
 supervisely/api/agent_api.py,sha256=ShWAIlXcWXcyI9fqVuP5GZVCigCMJmjnvdGUfLspD6Y,8890
 supervisely/api/annotation_api.py,sha256=XE3Sr_oQOMraZ9NlWs9ZqUsff1j47XRDh9Fy8rW4ubw,82763
-supervisely/api/api.py,sha256=D90G6ivwyHHK7WVo4ByKtv65lSED_Sm1qlp_TpyCeAc,67398
-supervisely/api/app_api.py,sha256=RsbVej8WxWVn9cNo5s3Fqd1symsCdsfOaKVBKEUapRY,71927
-supervisely/api/constants.py,sha256=qwK9Q3mHGz5Ny5WuBmPQgawBWfzCT2DRiw3IcaCDRmo,44
+supervisely/api/api.py,sha256=zAYool7iuceIaCVl_CGflp9KVGwnKf5z6BUagxEZA_w,67695
+supervisely/api/app_api.py,sha256=5lU3EU2NIwcatB6Uj3JUg_y-Qohsm6tfWK6M7MqEYKU,72442
+supervisely/api/constants.py,sha256=WfqIcEpRnU4Mcfb6q0njeRs2VVSoTAJaIyrqBkBjP8I,253
 supervisely/api/dataset_api.py,sha256=c6rEVySSxbyDB5fUCilsc5AKk0pWN_5vVN6OceDbEvc,47918
+supervisely/api/entities_collection_api.py,sha256=lIF10PVgdUOEjcG7dJuxgpN30cnmxw9-UNc6tEmukKo,9957
 supervisely/api/file_api.py,sha256=EX_Cam93QkR5SOOIkIznkzERIr0u7N7GHVGK27iOm20,92952
 supervisely/api/github_api.py,sha256=NIexNjEer9H5rf5sw2LEZd7C1WR-tK4t6IZzsgeAAwQ,623
 supervisely/api/image_annotation_tool_api.py,sha256=YcUo78jRDBJYvIjrd-Y6FJAasLta54nnxhyaGyanovA,5237
-supervisely/api/image_api.py,sha256=sE2lIPPYLv1tJsuFSjc9IvLVB07kmq9PnPodU3J6aEs,223637
+supervisely/api/image_api.py,sha256=8qs1AD8h1gyoibp9nZQ3b_A1Vid44Q103tmwRC-2hwQ,224419
 supervisely/api/import_storage_api.py,sha256=BDCgmR0Hv6OoiRHLCVPKt3iDxSVlQp1WrnKhAK_Zl84,460
 supervisely/api/issues_api.py,sha256=BqDJXmNoTzwc3xe6_-mA7FDFC5QQ-ahGbXk_HmpkSeQ,17925
-supervisely/api/labeling_job_api.py,sha256=VM1pjM65cUTeer1hrI7cSmCUOHJb7fzK6gJ-abA07hg,55097
-supervisely/api/module_api.py,sha256=Lou7blSb1wMwMnuZ0emyhHALdgRreJczOlGRJ0ZqLjE,44763
+supervisely/api/labeling_job_api.py,sha256=5xorizIYJlyBi-XtPiMyFz-COKR0V_KR5zVhd1kutSM,55187
+supervisely/api/labeling_queue_api.py,sha256=svQKbHtt8304FCFw_ZUoAHrCj3Yetj2RTdgTP_xTGks,28424
+supervisely/api/module_api.py,sha256=8lhsLIvZluHCB23MerHGdENWlfsj5gHIVwUVzMAkwgU,45283
 supervisely/api/neural_network_api.py,sha256=ktPVRO4Jeulougio8F0mioJJHwRJcX250Djp1wBoQ9c,7620
 supervisely/api/object_class_api.py,sha256=hBcQuKi9ouoiR7f99eot6vXHvqbzmal3IrHjJxuoFXg,10396
 supervisely/api/plugin_api.py,sha256=TlfrosdRuYG4NUxk92QiQoVaOdztFspPpygyVa3M3zk,5283
@@ -1067,7 +1069,7 @@ supervisely/volume_annotation/constants.py,sha256=BdFIh56fy7vzLIjt0gH8xP01EIU-qg
 supervisely/volume_annotation/plane.py,sha256=wyezAcc8tLp38O44CwWY0wjdQxf3VjRdFLWooCrk-Nw,16301
 supervisely/volume_annotation/slice.py,sha256=9m3jtUYz4PYKV3rgbeh2ofDebkyg4TomNbkC6BwZ0lA,4635
 supervisely/volume_annotation/volume_annotation.py,sha256=T-50ZmfhQDUtoXkSB9ur3LySCp9xZ1AmUT9KqjPy1DA,30179
-supervisely/volume_annotation/volume_figure.py,sha256=CWb5VePfJWeShwsCay4RDyylHQ0kg5zY6x4JUodxuro,25127
+supervisely/volume_annotation/volume_figure.py,sha256=3_X2drnt_zCGBLWPanW8_O-jM-tI9-34rSacUWqTflk,25329
 supervisely/volume_annotation/volume_object.py,sha256=rWzOnycoSJ4-CvFgDOP_rPortU4CdcYR26txe5wJHNo,3577
 supervisely/volume_annotation/volume_object_collection.py,sha256=Tc4AovntgoFj5hpTLBv7pCQ3eL0BjorOVpOh2nAE_tA,5706
 supervisely/volume_annotation/volume_tag.py,sha256=N2eOhAlbRDVVdSVQ83dzg7URDGtb1xHjxL2g9BW6ljU,9488
@@ -1083,9 +1085,9 @@ supervisely/worker_proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 supervisely/worker_proto/worker_api_pb2.py,sha256=VQfi5JRBHs2pFCK1snec3JECgGnua3Xjqw_-b3aFxuM,59142
 supervisely/worker_proto/worker_api_pb2_grpc.py,sha256=3BwQXOaP9qpdi0Dt9EKG--Lm8KGN0C5AgmUfRv77_Jk,28940
 supervisely_lib/__init__.py,sha256=7-3QnN8Zf0wj8NCr2oJmqoQWMKKPKTECvjH9pd2S5vY,159
-supervisely-6.73.355.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.355.dist-info/METADATA,sha256=DE9HbZdlEcZ9MLqTf-5GBkvaY6kYoomrBKAAK_8Od60,33598
-supervisely-6.73.355.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-supervisely-6.73.355.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.355.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.355.dist-info/RECORD,,
+supervisely-6.73.357.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.357.dist-info/METADATA,sha256=DdNugcuaOhnUNQMeJOHhj7x80PAPBkxnyKQencTMt-Q,33598
+supervisely-6.73.357.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+supervisely-6.73.357.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.357.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.357.dist-info/RECORD,,