supervisely 6.73.226__py3-none-any.whl → 6.73.227__py3-none-any.whl

supervisely/__init__.py

@@ -55,7 +55,7 @@ from supervisely.task.progress import (
 
 import supervisely.project as project
 from supervisely.project import read_project, get_project_class
-from supervisely.project.download import download
+from supervisely.project.download import download, download_async
 from supervisely.project.upload import upload
 from supervisely.project.project import (
     Project,

supervisely/_utils.py

@@ -1,5 +1,6 @@
 # coding: utf-8
 
+import asyncio
 import base64
 import copy
 import hashlib
@@ -382,3 +383,25 @@ def add_callback(func, callback):
         return res
 
     return wrapper
+
+
+def get_or_create_event_loop() -> asyncio.AbstractEventLoop:
+    """
+    Get the current event loop or create a new one if it doesn't exist.
+    Works for different Python versions and contexts.
+
+    :return: Event loop
+    :rtype: asyncio.AbstractEventLoop
+    """
+    try:
+        # Preferred method for asynchronous context (Python 3.7+)
+        return asyncio.get_running_loop()
+    except RuntimeError:
+        # If the loop is not running, get the current one or create a new one (Python 3.8 and 3.9)
+        try:
+            return asyncio.get_event_loop()
+        except RuntimeError:
+            # For Python 3.10+ or if the call occurs outside of an active loop context
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            return loop

supervisely/api/annotation_api.py

@@ -4,10 +4,11 @@
 # docs
 from __future__ import annotations
 
+import asyncio
 import json
 from collections import defaultdict
 from copy import deepcopy
-from typing import Any, Callable, Dict, List, NamedTuple, Optional, Union
+from typing import Any, Callable, Dict, List, Literal, NamedTuple, Optional, Union
 
 from tqdm import tqdm
 
@@ -1307,36 +1308,36 @@ class AnnotationApi(ModuleApi):
         Priority increases with the number: a higher number indicates a higher priority.
         The higher priority means that the label will be displayed on top of the others.
         The lower priority means that the label will be displayed below the others.
-        
+
         :param label_id: ID of the label to update
         :type label_id: int
         :param priority: New priority of the label
         :type priority: int
-        
-        :Usage example: 
-        
+
+        :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
             load_dotenv(os.path.expanduser("~/supervisely.env"))
-            
+
             api = sly.Api.from_env()
-            
+
             label_ids = [123, 456, 789]
             priorities = [1, 2, 3]
-            
+
             for label_id, priority in zip(label_ids, priorities):
                 api.annotation.update_label_priority(label_id, priority)
-                
+
             # The label with ID 789 will be displayed on top of the others.
             # The label with ID 123 will be displayed below the others.
-        
+
         """
         self._api.post(
             "figures.priority.update",
@@ -1344,4 +1345,173 @@ class AnnotationApi(ModuleApi):
                 ApiField.ID: label_id,
                 ApiField.PRIORITY: priority,
             },
-        )
+        )
+
+    async def download_async(
+        self,
+        image_id: int,
+        semaphore: Optional[asyncio.Semaphore] = None,
+        with_custom_data: Optional[bool] = False,
+        force_metadata_for_links: Optional[bool] = True,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        progress_cb_type: Literal["number", "size"] = "number",
+    ) -> AnnotationInfo:
+        """
+        Download AnnotationInfo by image ID from API.
+
+        :param image_id: Image ID in Supervisely.
+        :type image_id: int
+        :param semaphore: Semaphore for limiting the number of simultaneous downloads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param with_custom_data: Include custom data in the response.
+        :type with_custom_data: bool, optional
+        :param force_metadata_for_links: Force metadata for links.
+        :type force_metadata_for_links: bool, optional
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: tqdm or callable, optional
+        :param progress_cb_type: Type of progress callback. Can be "number" or "size". Default is "number".
+        :type progress_cb_type: str, optional
+        :return: Information about Annotation. See :class:`info_sequence<info_sequence>`
+        :rtype: :class:`AnnotationInfo`
+        :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()
+
+            image_id = 121236918
+            loop = sly.utils.get_or_create_event_loop()
+            ann_info = loop.run_until_complete(api.annotation.download_async(image_id))
+        """
+        if semaphore is None:
+            semaphore = self._api._get_default_semaphore()
+        async with semaphore:
+            response = await self._api.post_async(
+                "annotations.info",
+                {
+                    ApiField.IMAGE_ID: image_id,
+                    ApiField.WITH_CUSTOM_DATA: with_custom_data,
+                    ApiField.FORCE_METADATA_FOR_LINKS: force_metadata_for_links,
+                    ApiField.INTEGER_COORDS: False,
+                },
+            )
+            if progress_cb is not None and progress_cb_type == "size":
+                progress_cb(len(response.content))
+
+            result = response.json()
+            # Convert annotation to pixel coordinate system
+            result[ApiField.ANNOTATION] = Annotation._to_pixel_coordinate_system_json(
+                result[ApiField.ANNOTATION]
+            )
+            # check if there are any AlphaMask geometries in the batch
+            additonal_geometries = defaultdict(int)
+            labels = result[ApiField.ANNOTATION][AnnotationJsonFields.LABELS]
+            for idx, label in enumerate(labels):
+                if label[LabelJsonFields.GEOMETRY_TYPE] == AlphaMask.geometry_name():
+                    figure_id = label[LabelJsonFields.ID]
+                    additonal_geometries[figure_id] = idx
+
+            # if so, download them separately and update the annotation
+            if len(additonal_geometries) > 0:
+                figure_ids = list(additonal_geometries.keys())
+                figures = self._api.image.figure.download_geometries_batch(
+                    figure_ids,
+                    (
+                        progress_cb
+                        if progress_cb is not None and progress_cb_type == "size"
+                        else None
+                    ),
+                )
+                for figure_id, geometry in zip(figure_ids, figures):
+                    label_idx = additonal_geometries[figure_id]
+                    labels[label_idx].update({BITMAP: geometry})
+            ann_info = self._convert_json_info(result)
+            if progress_cb is not None and progress_cb_type == "number":
+                progress_cb(1)
+            return ann_info
+
+    async def download_batch_async(
+        self,
+        dataset_id: int,
+        image_ids: List[int],
+        semaphore: Optional[asyncio.Semaphore] = None,
+        with_custom_data: Optional[bool] = False,
+        force_metadata_for_links: Optional[bool] = True,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        progress_cb_type: Literal["number", "size"] = "number",
+    ) -> List[AnnotationInfo]:
+        """
+        Get list of AnnotationInfos for given dataset ID from API.
+
+        :param dataset_id: Dataset ID in Supervisely.
+        :type dataset_id: int
+        :param image_ids: List of integers.
+        :type image_ids: List[int]
+        :param semaphore: Semaphore for limiting the number of simultaneous downloads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param with_custom_data: Include custom data in the response.
+        :type with_custom_data: bool, optional
+        :param force_metadata_for_links: Force metadata for links.
+        :type force_metadata_for_links: bool, optional
+        :param progress_cb: Function for tracking download progress. Total should be equal to len(image_ids) or None.
+        :type progress_cb: tqdm or callable, optional
+        :param progress_cb_type: Type of progress callback. Can be "number" or "size". Default is "number".
+        :type progress_cb_type: str, optional
+        :return: Information about Annotations. See :class:`info_sequence<info_sequence>`
+        :rtype: :class:`List[AnnotationInfo]`
+
+        :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()
+
+            dataset_id = 254737
+            image_ids = [121236918, 121236919]
+            pbar = tqdm(desc="Download annotations", total=len(image_ids))
+
+            loop = sly.utils.get_or_create_event_loop()
+            ann_infos = loop.run_until_complete(
+                                api.annotation.download_batch_async(dataset_id, image_ids, progress_cb=pbar)
+                            )
+        """
+
+        # use context to avoid redundant API calls
+        context = self._api.optimization_context
+        context_dataset_id = context.get("dataset_id")
+        project_meta = context.get("project_meta")
+        project_id = context.get("project_id")
+        if dataset_id != context_dataset_id:
+            context["dataset_id"] = dataset_id
+            project_id, project_meta = None, None
+
+        if not isinstance(project_meta, ProjectMeta):
+            if project_id is None:
+                project_id = self._api.dataset.get_info_by_id(dataset_id).project_id
+                context["project_id"] = project_id
+            project_meta = ProjectMeta.from_json(self._api.project.get_meta(project_id))
+            context["project_meta"] = project_meta
+
+        if semaphore is None:
+            semaphore = self._api._get_default_semaphore()
+        tasks = []
+        for image in image_ids:
+            task = self.download_async(
+                image_id=image,
+                semaphore=semaphore,
+                with_custom_data=with_custom_data,
+                force_metadata_for_links=force_metadata_for_links,
+                progress_cb=progress_cb,
+                progress_cb_type=progress_cb_type,
+            )
+            tasks.append(task)
+        ann_infos = await asyncio.gather(*tasks)
+        return ann_infos

supervisely/api/api.py

@@ -1248,7 +1248,7 @@ class Api:
                         raise ValueError(
                             f"Streamed size does not match the expected: {total_streamed} != {expected_size}"
                         )
-                    logger.debug(f"Streamed size: {total_streamed}, expected size: {expected_size}")
+                    logger.trace(f"Streamed size: {total_streamed}, expected size: {expected_size}")
                     return
             except httpx.RequestError as e:
                 retry_range_start = total_streamed + (range_start or 0)
@@ -1478,7 +1478,7 @@ class Api:
                         raise ValueError(
                             f"Streamed size does not match the expected: {total_streamed} != {expected_size}"
                         )
-                    logger.debug(f"Streamed size: {total_streamed}, expected size: {expected_size}")
+                    logger.trace(f"Streamed size: {total_streamed}, expected size: {expected_size}")
                     return
             except httpx.RequestError as e:
                 retry_range_start = total_streamed + (range_start or 0)

supervisely/api/entity_annotation/figure_api.py

@@ -6,10 +6,11 @@ from __future__ import annotations
 import json
 import re
 from collections import defaultdict
-from typing import Dict, Generator, List, NamedTuple, Optional, Tuple
+from typing import Callable, Dict, Generator, List, NamedTuple, Optional, Tuple, Union
 
 import numpy as np
 from requests_toolbelt import MultipartDecoder, MultipartEncoder
+from tqdm import tqdm
 
 from supervisely._utils import batched
 from supervisely.api.module_api import ApiField, ModuleApi, RemoveableBulkModuleApi
@@ -540,17 +541,25 @@ class FigureApi(RemoveableBulkModuleApi):
         """
         return self.download_geometries_batch([figure_id])
 
-    def download_geometries_batch(self, ids: List[int]) -> List[dict]:
+    def download_geometries_batch(
+        self,
+        ids: List[int],
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> List[dict]:
         """
         Download figure geometries with given IDs from storage.
 
         :param ids: List of figure IDs in Supervisely.
         :type ids: List[int]
+        :param progress_cb: Progress bar to show the download progress. Shows the number of bytes downloaded.
+        :type progress_cb: Union[tqdm, Callable], optional
         :return: List of figure geometries in Supervisely JSON format.
         :rtype: List[dict]
         """
         geometries = {}
         for idx, part in self._download_geometries_generator(ids):
+            if progress_cb is not None:
+                progress_cb(len(part.content))
             geometry_json = json.loads(part.content)
             geometries[idx] = geometry_json
 

supervisely/api/file_api.py

@@ -14,6 +14,7 @@ from time import time
 from typing import Callable, Dict, List, NamedTuple, Optional, Union
 
 import aiofiles
+import httpx
 import requests
 from dotenv import load_dotenv
 from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
@@ -1641,8 +1642,7 @@ class FileApi(ModuleApiBase):
 
             path_to_file = "/999_App_Test/ds1/01587.json"
             local_save_path = "/path/to/save/999_App_Test/ds1/01587.json"
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(api.file.download_async(8, path_to_file, local_save_path))
         """
         if semaphore is None:
@@ -1756,8 +1756,7 @@ class FileApi(ModuleApiBase):
                 "/path/to/save/999_App_Test/ds1/01588.json",
                 "/path/to/save/999_App_Test/ds1/01587.json"
             ]
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(
                     api.file.download_bulk_async(8, paths_to_files, local_paths)
                 )
@@ -1830,8 +1829,7 @@ class FileApi(ModuleApiBase):
             path_to_dir = "/files/folder"
             local_path = "path/to/local/folder"
 
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(
                     api.file.download_directory_async(9, path_to_dir, local_path)
                 )
@@ -1918,8 +1916,7 @@ class FileApi(ModuleApiBase):
 
             # Application is started...
             save_path = "/my_app_data"
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(
                     api.file.download_input_async(save_path)
                 )
@@ -2008,3 +2005,142 @@ class FileApi(ModuleApiBase):
                 semaphore=semaphore,
                 show_progress=show_progress,
             )
+
+    async def upload_async(
+        self,
+        team_id: int,
+        src: str,
+        dst: str,
+        semaphore: Optional[asyncio.Semaphore] = None,
+        # chunk_size: int = 1024 * 1024, #TODO add with resumaple api
+        # check_hash: bool = True, #TODO add with resumaple api
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        progress_cb_type: Literal["number", "size"] = "size",
+    ) -> httpx.Response:
+        """
+        Upload file from local path to Team Files asynchronously.
+
+        :param team_id: Team ID in Supervisely.
+        :type team_id: int
+        :param src: Local path to file.
+        :type src: str
+        :param dst: Path to save file in Team Files.
+        :type dst: str
+        :param semaphore: Semaphore for limiting the number of simultaneous uploads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: tqdm or callable, optional
+        :param progress_cb_type: Type of progress callback. Can be "number" or "size". Default is "size".
+        :type progress_cb_type: Literal["number", "size"], optional
+        :return: Response from API.
+        :rtype: :class:`httpx.Response`
+        :Usage example:
+
+            .. code-block:: python
+
+                import supervisely as sly
+                import asyncio
+
+                os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+                os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+                api = sly.Api.from_env()
+
+                path_to_file = "/path/to/local/file/01587.json"
+                path_to_save = "/files/01587.json"
+                loop = sly.utils.get_or_create_event_loop()
+                loop.run_until_complete(
+                    api.file.upload_async(8, path_to_file, path_to_save)
+                )
+        """
+        api_method = "file-storage.upload"
+        headers = {"Content-Type": "application/octet-stream"}
+        # sha256 = await get_file_hash_async(src) #TODO add with resumaple api
+        json_body = {
+            ApiField.TEAM_ID: team_id,
+            ApiField.PATH: dst,
+            # "sha256": sha256, #TODO add with resumaple api
+        }
+        if semaphore is None:
+            semaphore = self._api._get_default_semaphore()
+        async with semaphore:
+            async with aiofiles.open(src, "rb") as fd:
+                item = await fd.read()
+                response = await self._api.post_async(
+                    api_method, content=item, params=json_body, headers=headers
+                )
+                if progress_cb is not None and progress_cb_type == "size":
+                    progress_cb(len(item))
+                if progress_cb is not None and progress_cb_type == "number":
+                    progress_cb(1)
+                return response
+
+    async def upload_bulk_async(
+        self,
+        team_id: int,
+        src_paths: List[str],
+        dst_paths: List[str],
+        semaphore: Optional[asyncio.Semaphore] = None,
+        # chunk_size: int = 1024 * 1024, #TODO add with resumaple api
+        # check_hash: bool = True, #TODO add with resumaple api
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        progress_cb_type: Literal["number", "size"] = "size",
+    ) -> None:
+        """
+        Upload multiple files from local paths to Team Files asynchronously.
+
+        :param team_id: Team ID in Supervisely.
+        :type team_id: int
+        :param src_paths: List of local paths to files.
+        :type src_paths: List[str]
+        :param dst_paths: List of paths to save files in Team Files.
+        :type dst_paths: List[str]
+        :param semaphore: Semaphore for limiting the number of simultaneous uploads.
+        :type semaphore: asyncio.Semaphore, optional
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: tqdm or callable, optional
+        :param progress_cb_type: Type of progress callback. Can be "number" or "size". Default is "size".
+        :type progress_cb_type: Literal["number", "size"], optional
+        :return: None
+        :rtype: :class:`NoneType`
+        :Usage example:
+
+            .. code-block:: python
+
+                import supervisely as sly
+                import asyncio
+
+                os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+                os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+                api = sly.Api.from_env()
+
+                paths_to_files = [
+                    "/path/to/local/file/01587.json",
+                    "/path/to/local/file/01588.json",
+                    "/path/to/local/file/01589.json"
+                ]
+                paths_to_save = [
+                    "/files/01587.json",
+                    "/files/01588.json",
+                    "/files/01589.json"
+                ]
+                loop = sly.utils.get_or_create_event_loop()
+                loop.run_until_complete(
+                    api.file.upload_bulk_async(8, paths_to_files, paths_to_save)
+                )
+        """
+        if semaphore is None:
+            semaphore = self._api._get_default_semaphore()
+        tasks = []
+        for s, d in zip(src_paths, dst_paths):
+            task = self.upload_async(
+                team_id,
+                s,
+                d,
+                semaphore=semaphore,
+                # chunk_size=chunk_size, #TODO add with resumaple api
+                # check_hash=check_hash, #TODO add with resumaple api
+                progress_cb=progress_cb,
+                progress_cb_type=progress_cb_type,
+            )
+            tasks.append(task)
+        await asyncio.gather(*tasks)

supervisely/api/image_api.py

@@ -3604,8 +3604,7 @@ class ImageApi(RemoveableBulkModuleApi):
                 semaphore = asyncio.Semaphore(100)
                 images = api.image.get_list(DATASET_ID)
                 img_ids = [image.id for image in images]
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
+                loop = sly.utils.get_or_create_event_loop()
                 results = loop.run_until_complete(
                                 api.image.download_nps_async(img_ids, semaphore)
                             )
@@ -3671,8 +3670,7 @@ class ImageApi(RemoveableBulkModuleApi):
             save_path = os.path.join("/path/to/save/", img_info.name)
 
             semaphore = asyncio.Semaphore(100)
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(
                     api.image.download_path_async(img_info.id, save_path, semaphore)
                 )
@@ -3756,8 +3754,7 @@ class ImageApi(RemoveableBulkModuleApi):
 
             ids = [770918, 770919]
             paths = ["/path/to/save/image1.png", "/path/to/save/image2.png"]
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(api.image.download_paths_async(ids, paths))
         """
         if len(ids) == 0:
@@ -3828,8 +3825,7 @@ class ImageApi(RemoveableBulkModuleApi):
             api = sly.Api.from_env()
 
             img_id = 770918
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             img_bytes = loop.run_until_complete(api.image.download_bytes_async(img_id))
 
         """
@@ -3906,8 +3902,7 @@ class ImageApi(RemoveableBulkModuleApi):
                 os.environ['API_TOKEN
                 api = sly.Api.from_env()
 
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
+                loop = sly.utils.get_or_create_event_loop()
                 semaphore = asyncio.Semaphore(100)
                 img_bytes_list = loop.run_until_complete(api.image.download_bytes_imgs_async(ids, semaphore))
         """

supervisely/api/pointcloud/pointcloud_api.py

@@ -1149,8 +1149,7 @@ class PointcloudApi(RemoveableBulkModuleApi):
             save_path = os.path.join("/path/to/save/", pcd_info.name)
 
             semaphore = asyncio.Semaphore(100)
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(
                         api.pointcloud.download_path_async(pcd_info.id, save_path, semaphore)
                     )
@@ -1241,8 +1240,7 @@ class PointcloudApi(RemoveableBulkModuleApi):
 
             ids = [19373403, 19373404]
             paths = ["/path/to/save/000063.pcd", "/path/to/save/000064.pcd"]
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(api.pointcloud.download_paths_async(ids, paths))
         """
         if len(ids) == 0:
@@ -1313,8 +1311,7 @@ class PointcloudApi(RemoveableBulkModuleApi):
             save_path = os.path.join("/path/to/save/", img_info.name)
 
             semaphore = asyncio.Semaphore(100)
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            loop = sly.utils.get_or_create_event_loop()
             loop.run_until_complete(
                     api.pointcloud.download_related_image_async(19373403, save_path, semaphore)
                 )
@@ -1395,8 +1392,7 @@ class PointcloudApi(RemoveableBulkModuleApi):
                 save_paths = [os.path.join("/path/to/save/", img_info.name) for img_info in img_infos]
 
                 semaphore = asyncio.Semaphore(100)
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
+                loop = sly.utils.get_or_create_event_loop()
                 loop.run_until_complete(
                         api.pointcloud.download_related_images_async(ids, save_paths, semaphore)
                     )

supervisely/api/video/video_annotation_api.py

@@ -1,6 +1,7 @@
 # coding: utf-8
 from __future__ import annotations
 
+import asyncio
 import json
 from typing import Callable, Dict, List, Optional, Union
 
@@ -247,3 +248,47 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
                 self.append(dst_id, ann)
                 if progress_cb is not None:
                     progress_cb(1)
+
+    async def download_async(
+        self,
+        video_id: int,
+        video_info=None,
+        semaphore: Optional[asyncio.Semaphore] = 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.
+        :type video_info: VideoInfo, optional
+        :param semaphore: Semaphore to limit the number of parallel downloads.
+        :type semaphore: asyncio.Semaphore, optional
+        :return: Information about VideoAnnotation 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()
+
+            video_id = 198702499
+            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)
+
+        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()