supervisely 6.73.258__tar.gz → 6.73.260__tar.gz

{supervisely-6.73.258/supervisely.egg-info → supervisely-6.73.260}/PKG-INFO

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

{supervisely-6.73.258 → supervisely-6.73.260}/supervisely/annotation/tag_meta.py

@@ -2,12 +2,14 @@
 """General information about :class:`Tag<supervisely.annotation.tag.Tag>`"""
 
 from __future__ import annotations
-from typing import List, Optional, Dict
+
 from copy import deepcopy
-from supervisely.imaging.color import random_rgb, rgb2hex, hex2rgb, _validate_color
-from supervisely.io.json import JsonSerializable
-from supervisely.collection.key_indexed_collection import KeyObject
+from typing import Dict, List, Optional
+
 from supervisely._utils import take_with_default
+from supervisely.collection.key_indexed_collection import KeyObject
+from supervisely.imaging.color import _validate_color, hex2rgb, random_rgb, rgb2hex
+from supervisely.io.json import JsonSerializable
 
 
 class TagValueType:
@@ -47,6 +49,7 @@ class TagMetaJsonFields:
     """"""
     APPLICABLE_CLASSES = "classes"
     """"""
+    TARGET_TYPE = "target_type"  # "Scope"
 
 
 class TagApplicableTo:
@@ -62,6 +65,19 @@ class TagApplicableTo:
     """"""
 
 
+class TagTargetType:
+    """
+    Defines Tag target type (scope) - entities, frames or both.
+    """
+
+    ALL = "all"  # both entities and frames
+    """"""
+    FRAME_BASED = "framesOnly"
+    """"""
+    GLOBAL = "entitiesOnly"
+    """"""
+
+
 SUPPORTED_TAG_VALUE_TYPES = [
     TagValueType.NONE,
     TagValueType.ANY_NUMBER,
@@ -74,6 +90,12 @@ SUPPORTED_APPLICABLE_TO = [
     TagApplicableTo.OBJECTS_ONLY,
 ]
 
+SUPPORTED_TARGET_TYPES = [
+    TagTargetType.ALL,
+    TagTargetType.FRAME_BASED,
+    TagTargetType.GLOBAL,
+]
+
 
 class TagMeta(KeyObject, JsonSerializable):
     """
@@ -95,6 +117,8 @@ class TagMeta(KeyObject, JsonSerializable):
     :type applicable_to: str, optional
     :param applicable_classes: Defines applicability of Tag only to certain classes.
     :type applicable_classes: List[str], optional
+    :param target_type: Defines Tag target type (scope) - entities, frames or both.
+    :type target_type: str, optional
     :raises: :class:`ValueError`, if color is not list, or doesn't have exactly 3 values
     :Usage example:
 
@@ -128,6 +152,7 @@ class TagMeta(KeyObject, JsonSerializable):
         hotkey: Optional[str] = None,
         applicable_to: Optional[str] = None,
         applicable_classes: Optional[List[str]] = None,
+        target_type: Optional[str] = None,
     ):
         if value_type not in SUPPORTED_TAG_VALUE_TYPES:
             raise ValueError(
@@ -144,12 +169,20 @@ class TagMeta(KeyObject, JsonSerializable):
         self._hotkey = take_with_default(hotkey, "")
         self._applicable_to = take_with_default(applicable_to, TagApplicableTo.ALL)
         self._applicable_classes = take_with_default(applicable_classes, [])
+        self._target_type = take_with_default(target_type, TagTargetType.ALL)
         if self._applicable_to not in SUPPORTED_APPLICABLE_TO:
             raise ValueError(
                 "applicable_to = {!r} is unknown, should be one of {}".format(
                     self._applicable_to, SUPPORTED_APPLICABLE_TO
                 )
             )
+        
+        if self._target_type not in SUPPORTED_TARGET_TYPES:
+            raise ValueError(
+                "target_type = {!r} is unknown, should be one of {}".format(
+                    self._target_type, SUPPORTED_TARGET_TYPES
+                )
+            )
 
         if self._value_type == TagValueType.ONEOF_STRING:
             if self._possible_values is None:
@@ -329,6 +362,24 @@ class TagMeta(KeyObject, JsonSerializable):
             # Output: ['car', 'bicycle']
         """
         return self._applicable_classes
+    
+    @property
+    def target_type(self) -> str:
+        """
+        Tag target type (scope) - entities, frames or both.
+
+        :return: Target type
+        :rtype: :class:`str`
+        :Usage example:
+
+         .. code-block:: python
+
+            meta_dog = sly.TagMeta('dog', sly.TagValueType.NONE, target_type=TagTargetType.FRAME_BASED)
+
+            print(meta_dog.target_type)
+            # Output: 'framesOnly'
+        """
+        return self._target_type
 
     def to_json(self) -> Dict:
         """
@@ -390,6 +441,8 @@ class TagMeta(KeyObject, JsonSerializable):
             jdict[TagMetaJsonFields.APPLICABLE_TYPE] = self.applicable_to
         if self._applicable_classes is not None:
             jdict[TagMetaJsonFields.APPLICABLE_CLASSES] = self.applicable_classes
+        if self._target_type is not None:
+            jdict[TagMetaJsonFields.TARGET_TYPE] = self.target_type
 
         return jdict
 
@@ -445,6 +498,7 @@ class TagMeta(KeyObject, JsonSerializable):
             hotkey = data.get(TagMetaJsonFields.HOTKEY, "")
             applicable_to = data.get(TagMetaJsonFields.APPLICABLE_TYPE, TagApplicableTo.ALL)
             applicable_classes = data.get(TagMetaJsonFields.APPLICABLE_CLASSES, [])
+            target_type = data.get(TagMetaJsonFields.TARGET_TYPE, TagTargetType.ALL)
 
             return cls(
                 name=name,
@@ -455,6 +509,7 @@ class TagMeta(KeyObject, JsonSerializable):
                 hotkey=hotkey,
                 applicable_to=applicable_to,
                 applicable_classes=applicable_classes,
+                target_type=target_type,
             )
         else:
             raise ValueError("Tags must be dict or str types.")
@@ -632,6 +687,7 @@ class TagMeta(KeyObject, JsonSerializable):
         hotkey: Optional[str] = None,
         applicable_to: Optional[str] = None,
         applicable_classes: Optional[List[str]] = None,
+        target_type: Optional[str] = None,
     ) -> TagMeta:
         """
         Clone makes a copy of TagMeta with new fields, if fields are given, otherwise it will use original TagMeta fields.
@@ -683,6 +739,7 @@ class TagMeta(KeyObject, JsonSerializable):
             hotkey=take_with_default(hotkey, self.hotkey),
             applicable_to=take_with_default(applicable_to, self.applicable_to),
             applicable_classes=take_with_default(applicable_classes, self.applicable_classes),
+            target_type=take_with_default(target_type, self.target_type),
         )
 
     def __str__(self):
@@ -713,6 +770,7 @@ class TagMeta(KeyObject, JsonSerializable):
             "Hotkey",
             "Applicable to",
             "Applicable classes",
+            "Target type",
         ]
 
     def get_row_ptable(self):
@@ -724,6 +782,7 @@ class TagMeta(KeyObject, JsonSerializable):
             self.hotkey,
             self.applicable_to,
             self.applicable_classes,
+            self.target_type,
         ]
 
     def _set_id(self, id: int):

{supervisely-6.73.258 → supervisely-6.73.260}/supervisely/api/pointcloud/pointcloud_annotation_api.py

@@ -1,8 +1,12 @@
 # coding: utf-8
 
 # docs
-from typing import Dict, List, NamedTuple, Optional
+import asyncio
+from typing import Callable, Dict, List, Optional, Union
 
+from tqdm import tqdm
+
+from supervisely._utils import batched
 from supervisely.api.entity_annotation.entity_annotation_api import EntityAnnotationAPI
 from supervisely.api.module_api import ApiField
 from supervisely.pointcloud_annotation.pointcloud_annotation import PointcloudAnnotation
@@ -174,3 +178,92 @@ class PointcloudAnnotationAPI(EntityAnnotationAPI):
             ann.figures,
             key_id_map,
         )
+
+    async def download_async(
+        self,
+        pointcloud_id: int,
+        semaphore: Optional[asyncio.Semaphore] = None,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> Dict:
+        """
+        Download information about PointcloudAnnotation by Point Cloud ID from API asynchronously.
+
+        :param pointcloud_id: Point Cloud ID in Supervisely.
+        :type pointcloud_id: int
+        :param semaphore: Semaphore to limit the number of parallel downloads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param progress_cb: Progress callback to track download progress.
+        :type progress_cb: Union[tqdm, Callable], optional
+        :return: Information about PointcloudAnnotation in json format
+        :rtype: :class:`dict`
+
+        :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()
+
+            pointcloud_id = 198702499
+            loop = sly.utils.get_or_create_event_loop()
+            ann_info = loop.run_until_complete(api.pointcloud.annotation.download_async(pointcloud_id))
+        """
+        return await self.download_bulk_async(
+            pointcloud_ids=[pointcloud_id],
+            semaphore=semaphore,
+            progress_cb=progress_cb,
+        )
+
+    async def download_bulk_async(
+        self,
+        pointcloud_ids: List[int],
+        semaphore: Optional[asyncio.Semaphore] = None,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> List[Dict]:
+        """
+        Download information about PointcloudAnnotation in bulk by Point Cloud IDs from API asynchronously.
+
+        :param pointcloud_ids: Point Cloud IDs in Supervisely.
+        :type pointcloud_ids: List[int]
+        :param semaphore: Semaphore to limit the number of parallel downloads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param progress_cb: Progress callback to track download progress.
+        :type progress_cb: Union[tqdm, Callable], optional
+        :return: Information about PointcloudAnnotations in json format
+        :rtype: :class:`list`
+
+        :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()
+
+            pointcloud_ids = [198702499, 198702500, 198702501]
+            loop = sly.utils.get_or_create_event_loop()
+            ann_infos = loop.run_until_complete(api.pointcloud.annotation.download_bulk_async(pointcloud_ids))
+        """
+        if semaphore is None:
+            semaphore = self._api.get_default_semaphore()
+
+        async def fetch_with_semaphore(batch):
+            async with semaphore:
+                json_data = {self._entity_ids_str: batch}
+                response = await self._api.post_async(
+                    self._method_download_bulk,
+                    json=json_data,
+                )
+                if progress_cb is not None:
+                    progress_cb(len(batch))
+                return response.json()
+
+        tasks = [fetch_with_semaphore(batch) for batch in batched(pointcloud_ids)]
+        responses = await asyncio.gather(*tasks)
+        json_response = [item for response in responses for item in response]
+        return json_response

{supervisely-6.73.258 → supervisely-6.73.260}/supervisely/api/video/video_annotation_api.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import asyncio
-import json
 from typing import Callable, Dict, List, Optional, Union
 
 from tqdm import tqdm
@@ -12,7 +11,6 @@ from supervisely.api.entity_annotation.entity_annotation_api import EntityAnnota
 from supervisely.api.module_api import ApiField
 from supervisely.io.json import load_json_file
 from supervisely.project.project_meta import ProjectMeta
-from supervisely.task.progress import Progress
 from supervisely.video_annotation.key_id_map import KeyIdMap
 from supervisely.video_annotation.video_annotation import VideoAnnotation
 
@@ -254,18 +252,28 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
         video_id: int,
         video_info=None,
         semaphore: Optional[asyncio.Semaphore] = None,
+        force_metadata_for_links: bool = True,
+        integer_coords: bool = True,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
     ) -> Dict:
         """
         Download information about VideoAnnotation by video ID from API asynchronously.
 
         :param video_id: Video ID in Supervisely.
         :type video_id: int
-        :param video_info: VideoInfo object. Use it to avoid additional request to the server.
+        :param video_info: Does not affect the result, but is left for compatibility with the method signature.
         :type video_info: VideoInfo, optional
         :param semaphore: Semaphore to limit the number of parallel downloads.
         :type semaphore: asyncio.Semaphore, optional
+        :param force_metadata_for_links: If True, updates meta for videos with links.
+        :type force_metadata_for_links: bool, optional
+        :param integer_coords: If True, returns coordinates as integers for objects. If False, returns as floats.
+        :type integer_coords: bool, optional
+        :param progress_cb: Progress callback to track download progress.
+        :type progress_cb: Union[tqdm, Callable], optional
         :return: Information about VideoAnnotation in json format
         :rtype: :class:`dict`
+
         :Usage example:
 
          .. code-block:: python
@@ -280,15 +288,74 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
             loop = sly.utils.get_or_create_event_loop()
             ann_info = loop.run_until_complete(api.video.annotation.download_async(video_id))
         """
-        if video_info is None:
-            video_info = self._api.video.get_info_by_id(video_id)
+        return await self.download_bulk_async(
+            video_ids=[video_id],
+            semaphore=semaphore,
+            force_metadata_for_links=force_metadata_for_links,
+            integer_coords=integer_coords,
+            progress_cb=progress_cb,
+        )
 
+    async def download_bulk_async(
+        self,
+        video_ids: List[int],
+        semaphore: Optional[asyncio.Semaphore] = None,
+        force_metadata_for_links: bool = True,
+        integer_coords: bool = True,
+        batch_size: int = 10,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> List[Dict]:
+        """
+        Download information about VideoAnnotation in bulk by video IDs from API asynchronously.
+
+        :param video_ids: List of Video IDs in Supervisely. All videos must be from the same dataset.
+        :type video_ids: int
+        :param semaphore: Semaphore to limit the number of parallel downloads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param force_metadata_for_links: If True, updates meta for videos with links.
+        :type force_metadata_for_links: bool, optional
+        :param integer_coords: If True, returns coordinates as integers for objects. If False, returns as floats.
+        :type integer_coords: bool, optional
+        :param batch_size: Batch size for parallel downloads. Default is 10 as an optimal value.
+        :type batch_size: int, optional
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: tqdm or callable, optional
+        :return: Information about VideoAnnotations in json format
+        :rtype: :class:`list`
+
+        :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()
+
+            video_ids = [198702499, 198702500, 198702501]
+            loop = sly.utils.get_or_create_event_loop()
+            ann_infos = loop.run_until_complete(api.video.annotation.download_bulk_async(video_ids))
+        """
         if semaphore is None:
             semaphore = self._api.get_default_semaphore()
 
-        async with semaphore:
-            response = await self._api.post_async(
-                self._method_download_bulk,
-                {ApiField.DATASET_ID: video_info.dataset_id, self._entity_ids_str: [video_info.id]},
-            )
-            return response.json()
+        async def fetch_with_semaphore(batch):
+            async with semaphore:
+                json_data = {
+                    self._entity_ids_str: batch,
+                    ApiField.FORCE_METADATA_FOR_LINKS: force_metadata_for_links,
+                    ApiField.INTEGER_COORDS: integer_coords,
+                }
+                response = await self._api.post_async(
+                    self._method_download_bulk,
+                    json=json_data,
+                )
+                if progress_cb is not None:
+                    progress_cb(len(batch))
+                return response.json()
+
+        tasks = [fetch_with_semaphore(batch) for batch in batched(video_ids, batch_size=batch_size)]
+        responses = await asyncio.gather(*tasks)
+        json_response = [item for response in responses for item in response]
+        return json_response

{supervisely-6.73.258 → supervisely-6.73.260}/supervisely/api/volume/volume_annotation_api.py

@@ -1,16 +1,17 @@
 # coding: utf-8
 
+import asyncio
 import os
 import re
-from typing import Callable, List, Literal, Optional, Tuple, Union
+from typing import Callable, Dict, List, Literal, Optional, Tuple, Union
 
 import numpy as np
 from tqdm import tqdm
 
+from supervisely._utils import batched
 from supervisely.annotation.obj_class import ObjClass
 from supervisely.api.entity_annotation.entity_annotation_api import EntityAnnotationAPI
 from supervisely.api.module_api import ApiField
-from supervisely.collection.key_indexed_collection import DuplicateKeyError
 from supervisely.geometry.any_geometry import AnyGeometry
 from supervisely.geometry.mask_3d import Mask3D
 from supervisely.io.fs import (
@@ -456,3 +457,102 @@ class VolumeAnnotationAPI(EntityAnnotationAPI):
                         nrrd_paths.remove(nrrd_path)
                         keep_nrrd_paths.remove(nrrd_path)
         return stl_paths, nrrd_paths, keep_nrrd_paths
+
+    async def download_async(
+        self,
+        volume_id: int,
+        semaphore: Optional[asyncio.Semaphore] = None,
+        integer_coords: bool = True,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> Dict:
+        """
+        Download information about VolumeAnnotation by volume ID from API asynchronously.
+
+        :param volume_id: Volume ID in Supervisely.
+        :type volume_id: int
+        :param semaphore: Semaphore to limit the number of parallel downloads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param integer_coords: If True, returns coordinates as integers for objects. If False, returns as floats.
+        :type integer_coords: bool, optional
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: tqdm or callable, optional
+        :return: Information about VolumeAnnotation in json format
+        :rtype: :class:`dict`
+
+        :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()
+
+            volume_id = 198702499
+            loop = sly.utils.get_or_create_event_loop()
+            ann_info = loop.run_until_complete(api.volume.annotation.download_async(volume_id))
+        """
+        return await self.download_bulk_async(
+            volume_ids=[volume_id],
+            semaphore=semaphore,
+            integer_coords=integer_coords,
+            progress_cb=progress_cb,
+        )
+
+    async def download_bulk_async(
+        self,
+        volume_ids: List[int],
+        semaphore: Optional[asyncio.Semaphore] = None,
+        integer_coords: bool = True,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> List[Dict]:
+        """
+        Download information about VolumeAnnotation in bulk by volume IDs from API asynchronously.
+
+        :param volume_ids: List of Volume IDs in Supervisely. All volumes must be from the same dataset.
+        :type volume_ids: int
+        :param semaphore: Semaphore to limit the number of parallel downloads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param integer_coords: If True, returns coordinates as integers for objects. If False, returns as floats.
+        :type integer_coords: bool, optional
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: tqdm or callable, optional
+        :return: Information about VolumeAnnotations in json format
+        :rtype: :class:`list`
+
+        :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()
+
+            volume_ids = [198702499, 198702500, 198702501]
+            loop = sly.utils.get_or_create_event_loop()
+            ann_infos = loop.run_until_complete(api.volume.annotation.download_bulk_async(volume_ids))
+        """
+        if semaphore is None:
+            semaphore = self._api.get_default_semaphore()
+
+        async def fetch_with_semaphore(batch):
+            async with semaphore:
+                json_data = {
+                    self._entity_ids_str: batch,
+                    ApiField.INTEGER_COORDS: integer_coords,
+                }
+                response = await self._api.post_async(
+                    self._method_download_bulk,
+                    json=json_data,
+                )
+                if progress_cb is not None:
+                    progress_cb(len(batch))
+                return response.json()
+
+        tasks = [fetch_with_semaphore(batch) for batch in batched(volume_ids)]
+        responses = await asyncio.gather(*tasks)
+        json_response = [item for response in responses for item in response]
+        return json_response

{supervisely-6.73.258 → supervisely-6.73.260/supervisely.egg-info}/PKG-INFO

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