supervisely 6.73.221__py3-none-any.whl → 6.73.222__py3-none-any.whl

supervisely/api/volume/volume_api.py

@@ -1,6 +1,8 @@
+import asyncio
 import os
-from typing import Callable, List, NamedTuple, Optional, Union
+from typing import AsyncGenerator, Callable, List, NamedTuple, Optional, Union
 
+import aiofiles
 from tqdm import tqdm
 from tqdm.contrib.logging import logging_redirect_tqdm
 
@@ -19,6 +21,7 @@ from supervisely.io.fs import (
     ensure_base_path,
     get_bytes_hash,
     get_file_ext,
+    get_file_hash_async,
     get_file_name,
     get_file_name_with_ext,
 )
@@ -852,7 +855,7 @@ class VolumeApi(RemoveableBulkModuleApi):
 
     def _download(self, id: int, is_stream: bool = False):
         """
-        Private method for volume volume downloading.
+        Private method for volume downloading.
 
         :param id: Volume ID in Supervisely.
         :type id: int
@@ -1236,3 +1239,221 @@ class VolumeApi(RemoveableBulkModuleApi):
                 )
             )
         return volume_infos
+
+    async def _download_async(
+        self,
+        id: int,
+        is_stream: bool = False,
+        range_start: Optional[int] = None,
+        range_end: Optional[int] = None,
+        headers: Optional[dict] = None,
+        chunk_size: int = 1024 * 1024,
+    ) -> AsyncGenerator:
+        """
+        Download Volume with given ID asynchronously.
+        If is_stream is True, returns stream of bytes, otherwise returns response object.
+        For streaming, returns tuple of chunk and hash.
+
+        :param id: Volume ID in Supervisely.
+        :type id: int
+        :param is_stream: If True, returns stream of bytes, otherwise returns response object.
+        :type is_stream: bool, optional
+        :param range_start: Start byte of range for partial download.
+        :type range_start: int, optional
+        :param range_end: End byte of range for partial download.
+        :type range_end: int, optional
+        :param headers: Headers for request.
+        :type headers: dict, optional
+        :param chunk_size: Size of chunk for downloading. Default is 1MB.
+        :type chunk_size: int, optional
+        :return: Stream of bytes or response object.
+        :rtype: AsyncGenerator
+        """
+        api_method_name = "volumes.download"
+
+        json_body = {ApiField.ID: id}
+
+        if is_stream:
+            async for chunk, hhash in self._api.stream_async(
+                api_method_name,
+                "POST",
+                json_body,
+                headers=headers,
+                range_start=range_start,
+                range_end=range_end,
+                chunk_size=chunk_size,
+            ):
+                yield chunk, hhash
+        else:
+            response = await self._api.post_async(api_method_name, json_body, headers=headers)
+            yield response
+
+    async def download_path_async(
+        self,
+        id: int,
+        path: str,
+        semaphore: Optional[asyncio.Semaphore] = None,
+        range_start: Optional[int] = None,
+        range_end: Optional[int] = None,
+        headers: Optional[dict] = None,
+        chunk_size: int = 1024 * 1024,
+        check_hash: bool = True,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        progress_cb_type: Literal["number", "size"] = "number",
+    ) -> None:
+        """
+        Downloads Volume with given ID to local path.
+
+        :param id: Volume ID in Supervisely.
+        :type id: int
+        :param path: Local save path for Volume.
+        :type path: str
+        :param semaphore: Semaphore for limiting the number of simultaneous downloads.
+        :type semaphore: :class:`asyncio.Semaphore`, optional
+        :param range_start: Start byte of range for partial download.
+        :type range_start: int, optional
+        :param range_end: End byte of range for partial download.
+        :type range_end: int, optional
+        :param headers: Headers for request.
+        :type headers: dict, optional
+        :param chunk_size: Size of chunk for downloading. Default is 1MB.
+        :type chunk_size: int, optional
+        :param check_hash: If True, checks hash of downloaded file.
+                        Check is not supported for partial downloads.
+                        When range is set, hash check is disabled.
+        :type check_hash: 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: 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()
+
+            volume_info = api.volume.get_info_by_id(770918)
+            save_path = os.path.join("/path/to/save/", volume_info.name)
+
+            semaphore = asyncio.Semaphore(100)
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(
+                        api.volume.download_path_async(volume_info.id, save_path, semaphore)
+                )
+        """
+
+        if range_start is not None or range_end is not None:
+            check_hash = False  # Hash check is not supported for partial downloads
+            headers = headers or {}
+            headers["Range"] = f"bytes={range_start or ''}-{range_end or ''}"
+            logger.debug(f"Image ID: {id}. Setting Range header: {headers['Range']}")
+
+        writing_method = "ab" if range_start not in [0, None] else "wb"
+
+        ensure_base_path(path)
+        hash_to_check = None
+        if semaphore is None:
+            semaphore = self._api._get_default_semaphore()
+        async with semaphore:
+            async with aiofiles.open(path, writing_method) as fd:
+                async for chunk, hhash in self._download_async(
+                    id,
+                    is_stream=True,
+                    headers=headers,
+                    range_start=range_start,
+                    range_end=range_end,
+                    chunk_size=chunk_size,
+                ):
+                    await fd.write(chunk)
+                    hash_to_check = hhash
+                    if progress_cb is not None and progress_cb_type == "size":
+                        progress_cb(len(chunk))
+            if check_hash:
+                if hash_to_check is not None:
+                    downloaded_file_hash = await get_file_hash_async(path)
+                    if hash_to_check != downloaded_file_hash:
+                        raise RuntimeError(
+                            f"Downloaded hash of volume with ID:{id} does not match the expected hash: {downloaded_file_hash} != {hash_to_check}"
+                        )
+            if progress_cb is not None and progress_cb_type == "number":
+                progress_cb(1)
+
+    async def download_paths_async(
+        self,
+        ids: List[int],
+        paths: List[str],
+        semaphore: Optional[asyncio.Semaphore] = None,
+        headers: Optional[dict] = None,
+        chunk_size: int = 1024 * 1024,
+        check_hash: bool = True,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        progress_cb_type: Literal["number", "size"] = "number",
+    ) -> None:
+        """
+        Download Volumes with given IDs and saves them to given local paths asynchronously.
+
+        :param ids: List of Volume IDs in Supervisely.
+        :type ids: :class:`List[int]`
+        :param paths: Local save paths for Volumes.
+        :type paths: :class:`List[str]`
+        :param semaphore: Semaphore for limiting the number of simultaneous downloads.
+        :type semaphore: :class:`asyncio.Semaphore`, optional
+        :param headers: Headers for request.
+        :type headers: dict, optional
+        :param chunk_size: Size of chunk for downloading. Default is 1MB.
+        :type chunk_size: int, optional
+        :param check_hash: If True, checks hash of downloaded file.
+        :type check_hash: 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
+        :raises: :class:`ValueError` if len(ids) != len(paths)
+        :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()
+
+            ids = [770914, 770915]
+            paths = ["/path/to/save/volume1.nrrd", "/path/to/save/volume2.nrrd"]
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(api.volume.download_paths_async(ids, paths))
+        """
+        if len(ids) == 0:
+            return
+        if len(ids) != len(paths):
+            raise ValueError(f'Can not match "ids" and "paths" lists, {len(ids)} != {len(paths)}')
+        if semaphore is None:
+            semaphore = self._api._get_default_semaphore()
+        tasks = []
+        for img_id, img_path in zip(ids, paths):
+            task = self.download_path_async(
+                img_id,
+                img_path,
+                semaphore,
+                headers=headers,
+                chunk_size=chunk_size,
+                check_hash=check_hash,
+                progress_cb=progress_cb,
+                progress_cb_type=progress_cb_type,
+            )
+            tasks.append(task)
+        await asyncio.gather(*tasks)

supervisely/convert/base_converter.py

@@ -5,11 +5,12 @@ from typing import Dict, List, Optional, Tuple, Union
 
 from tqdm import tqdm
 
-from supervisely._utils import is_production
+from supervisely._utils import batched, is_production
 from supervisely.annotation.annotation import Annotation
 from supervisely.annotation.tag_meta import TagValueType
 from supervisely.api.api import Api
-from supervisely.io.fs import get_file_ext, get_file_name_with_ext
+from supervisely.io.env import team_id
+from supervisely.io.fs import get_file_ext, get_file_name_with_ext, silent_remove
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.project.project_settings import LabelingInterface
 from supervisely.sly_logger import logger
@@ -145,12 +146,16 @@ class BaseConverter:
         remote_files_map: Optional[Dict[str, str]] = None,
     ):
         self._input_data: str = input_data
-        self._items: List[self.BaseItem] = []
+        self._items: List[BaseConverter.BaseItem] = []
         self._meta: ProjectMeta = None
         self._labeling_interface = labeling_interface or LabelingInterface.DEFAULT
+
+        # import as links settings
         self._upload_as_links: bool = upload_as_links
         self._remote_files_map: Optional[Dict[str, str]] = remote_files_map
         self._supports_links = False  # if converter supports uploading by links
+        self._api = Api.from_env() if self._upload_as_links else None
+        self._team_id = team_id() if self._upload_as_links else None
         self._converter = None
 
         if self._labeling_interface not in LabelingInterface.values():
@@ -419,3 +424,39 @@ class BaseConverter:
 
             return meta1.clone(project_settings=new_settings)
         return meta1
+
+    def _download_remote_ann_files(self) -> None:
+        """
+        Download all annotation files from Cloud Storage to the local storage.
+        Needed to detect annotation format if "upload_as_links" is enabled.
+        """
+        if not self.upload_as_links:
+            return
+
+        files_to_download = {
+            l: r for l, r in self._remote_files_map.items() if get_file_ext(l) == self.ann_ext
+        }
+        if not files_to_download:
+            return
+
+        import asyncio
+
+        loop = asyncio.get_event_loop()
+        _, progress_cb = self.get_progress(
+            len(files_to_download),
+            "Downloading annotation files from remote storage",
+        )
+
+        for local_path in files_to_download.keys():
+            silent_remove(local_path)
+
+        logger.info("Downloading annotation files from remote storage...")
+        loop.run_until_complete(
+            self._api.storage.download_bulk_async(
+                team_id=self._team_id,
+                remote_paths=list(files_to_download.values()),
+                local_save_paths=list(files_to_download.keys()),
+                progress_cb=progress_cb,
+            )
+        )
+        logger.info("Annotation files downloaded successfully")

supervisely/convert/converter.py

@@ -1,15 +1,16 @@
 import os
 from pathlib import Path
+from typing import Optional
 
 from tqdm import tqdm
 
-from typing import Literal, Optional
-
 from supervisely._utils import is_production
 from supervisely.api.api import Api
 from supervisely.app import get_data_dir
 from supervisely.convert.image.csv.csv_converter import CSVConverter
-from supervisely.convert.image.high_color.high_color_depth import HighColorDepthImageConverter
+from supervisely.convert.image.high_color.high_color_depth import (
+    HighColorDepthImageConverter,
+)
 from supervisely.convert.image.image_converter import ImageConverter
 from supervisely.convert.pointcloud.pointcloud_converter import PointcloudConverter
 from supervisely.convert.pointcloud_episodes.pointcloud_episodes_converter import (
@@ -28,10 +29,10 @@ from supervisely.io.fs import (
     touch,
     unpack_archive,
 )
+from supervisely.project.project_settings import LabelingInterface
 from supervisely.project.project_type import ProjectType
 from supervisely.sly_logger import logger
 from supervisely.task.progress import Progress
-from supervisely.project.project_settings import LabelingInterface
 
 
 class ImportManager:
@@ -164,7 +165,7 @@ class ImportManager:
         dir_path = remote_path.rstrip("/") if is_dir else os.path.dirname(remote_path)
         dir_name = os.path.basename(dir_path)
 
-        local_path = os.path.join(get_data_dir(), dir_name)
+        local_path = os.path.abspath(os.path.join(get_data_dir(), dir_name))
         mkdir(local_path, remove_content_if_exists=True)
 
         if is_dir:

supervisely/convert/image/image_converter.py

@@ -137,8 +137,8 @@ class ImageConverter(BaseConverter):
                 if item.path is None:
                     continue  # image has failed validation
                 item.name = f"{get_file_name(item.path)}{get_file_ext(item.path).lower()}"
-                if self.upload_as_links:
-                    ann = None  # TODO: implement
+                if self.upload_as_links and not self.supports_links:
+                    ann = None
                 else:
                     ann = self.to_supervisely(item, meta, renamed_classes, renamed_tags)
                 name = generate_free_name(
@@ -160,19 +160,29 @@ class ImageConverter(BaseConverter):
             with ApiContext(
                 api=api, project_id=project_id, dataset_id=dataset_id, project_meta=meta
             ):
-                upload_method = (
-                    api.image.upload_links if self.upload_as_links else api.image.upload_paths
-                )
-                img_infos = upload_method(
-                    dataset_id,
-                    item_names,
-                    item_paths,
-                    metas=item_metas,
-                    conflict_resolution="rename",
-                )
+                if self.upload_as_links:
+                    img_infos = api.image.upload_links(
+                        dataset_id,
+                        item_names,
+                        item_paths,
+                        metas=item_metas,
+                        conflict_resolution="rename",
+                        force_metadata_for_links=False,
+                    )
+                else:
+                    img_infos = api.image.upload_paths(
+                        dataset_id,
+                        item_names,
+                        item_paths,
+                        metas=item_metas,
+                        conflict_resolution="rename",
+                    )
+
                 img_ids = [img_info.id for img_info in img_infos]
                 if len(anns) == len(img_ids):
-                    api.annotation.upload_anns(img_ids, anns)
+                    api.annotation.upload_anns(
+                        img_ids, anns, skip_bounds_validation=self.upload_as_links
+                    )
 
             if log_progress:
                 progress_cb(len(batch))
@@ -188,6 +198,9 @@ class ImageConverter(BaseConverter):
         return image_helper.validate_image(path)
 
     def is_image(self, path: str) -> bool:
+        if self._upload_as_links and self.supports_links:
+            ext = get_file_ext(path)
+            return ext.lower() in self.allowed_exts
         mimetypes.add_type("image/heic", ".heic")  # to extend types_map
         mimetypes.add_type("image/heif", ".heif")  # to extend types_map
         mimetypes.add_type("image/jpeg", ".jfif")  # to extend types_map

supervisely/convert/image/sly/fast_sly_image_converter.py

@@ -20,6 +20,10 @@ from supervisely.convert.image.image_helper import validate_image_bounds
 
 class FastSlyImageConverter(SLYImageConverter, ImageConverter):
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._supports_links = False
+
     def validate_format(self) -> bool:
 
         detected_ann_cnt = 0

supervisely/convert/image/sly/sly_image_converter.py

@@ -2,21 +2,21 @@ import os
 from typing import Dict, Optional
 
 import supervisely.convert.image.sly.sly_image_helper as sly_image_helper
-from supervisely.convert.image.image_helper import validate_image_bounds
 from supervisely import (
     Annotation,
     Dataset,
+    Label,
     OpenMode,
     Project,
     ProjectMeta,
     Rectangle,
-    Label,
     logger,
 )
 from supervisely._utils import generate_free_name
 from supervisely.api.api import Api
 from supervisely.convert.base_converter import AvailableImageConverters
 from supervisely.convert.image.image_converter import ImageConverter
+from supervisely.convert.image.image_helper import validate_image_bounds
 from supervisely.io.fs import dirs_filter, file_exists, get_file_ext
 from supervisely.io.json import load_json_file
 from supervisely.project.project import find_project_dirs
@@ -31,6 +31,7 @@ class SLYImageConverter(ImageConverter):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._project_structure = None
+        self._supports_links = True
 
     def __str__(self):
         return AvailableImageConverters.SLY
@@ -74,6 +75,8 @@ class SLYImageConverter(ImageConverter):
             return False
 
     def validate_format(self) -> bool:
+        if self.upload_as_links and self._supports_links:
+            self._download_remote_ann_files()
         if self.read_sly_project(self._input_data):
             return True
 
@@ -136,6 +139,8 @@ class SLYImageConverter(ImageConverter):
             meta = self._meta
 
         if item.ann_data is None:
+            if self._upload_as_links:
+                item.set_shape([None, None])
             return item.create_empty_annotation()
 
         try:
@@ -151,7 +156,7 @@ class SLYImageConverter(ImageConverter):
             )
             return Annotation.from_json(ann_json, meta).clone(labels=labels)
         except Exception as e:
-            logger.warn(f"Failed to convert annotation: {repr(e)}")
+            logger.warning(f"Failed to convert annotation: {repr(e)}")
             return item.create_empty_annotation()
 
     def read_sly_project(self, input_data: str) -> bool:
@@ -163,7 +168,7 @@ class SLYImageConverter(ImageConverter):
             logger.debug("Trying to find Supervisely project format in the input data")
             project_dirs = [d for d in find_project_dirs(input_data)]
             if len(project_dirs) > 1:
-                logger.info("Found multiple Supervisely projects")
+                logger.info("Found multiple possible Supervisely projects in the input data")
             meta = None
             for project_dir in project_dirs:
                 project_fs = Project(project_dir, mode=OpenMode.READ)

supervisely/convert/video/sly/sly_video_converter.py

@@ -12,6 +12,10 @@ from supervisely.video.video import validate_ext as validate_video_ext
 
 class SLYVideoConverter(VideoConverter):
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._supports_links = True
+
     def __str__(self) -> str:
         return AvailableVideoConverters.SLY
 
@@ -45,6 +49,8 @@ class SLYVideoConverter(VideoConverter):
             return False
 
     def validate_format(self) -> bool:
+        if self.upload_as_links and self._supports_links:
+            self._download_remote_ann_files()
         detected_ann_cnt = 0
         videos_list, ann_dict = [], {}
         for root, _, files in os.walk(self._input_data):
@@ -103,6 +109,8 @@ class SLYVideoConverter(VideoConverter):
             meta = self._meta
 
         if item.ann_data is None:
+            if self._upload_as_links:
+                return None
             return item.create_empty_annotation()
 
         try:
@@ -113,5 +121,5 @@ class SLYVideoConverter(VideoConverter):
                 ann_json = sly_video_helper.rename_in_json(ann_json, renamed_classes, renamed_tags)
             return VideoAnnotation.from_json(ann_json, meta)
         except Exception as e:
-            logger.warn(f"Failed to convert annotation: {repr(e)}")
+            logger.warning(f"Failed to convert annotation: {repr(e)}")
             return item.create_empty_annotation()

supervisely/convert/video/video_converter.py

@@ -1,6 +1,6 @@
 import os
 import subprocess
-from typing import Dict, Optional, Union
+from typing import Dict, Optional, Tuple, Union
 
 import cv2
 import magic
@@ -57,10 +57,22 @@ class VideoConverter(BaseConverter):
                 self._frame_count = frame_count
             self._custom_data = custom_data if custom_data is not None else {}
 
+        @property
+        def shape(self) -> Tuple[int, int]:
+            return self._shape
+
+        @shape.setter
+        def shape(self, shape: Optional[Tuple[int, int]] = None):
+            self._shape = shape if shape is not None else [None, None]
+
         @property
         def frame_count(self) -> int:
             return self._frame_count
 
+        @frame_count.setter
+        def frame_count(self, frame_count: int):
+            self._frame_count = frame_count
+
         @property
         def name(self) -> str:
             if self._name is not None:
@@ -75,11 +87,11 @@ class VideoConverter(BaseConverter):
             return VideoAnnotation(self._shape, self._frame_count)
 
     def __init__(
-            self,
-            input_data: str,
-            labeling_interface: Optional[Union[LabelingInterface, str]],
-            upload_as_links: bool,
-            remote_files_map: Optional[Dict[str, str]] = None,
+        self,
+        input_data: str,
+        labeling_interface: Optional[Union[LabelingInterface, str]],
+        upload_as_links: bool,
+        remote_files_map: Optional[Dict[str, str]] = None,
     ):
         super().__init__(input_data, labeling_interface, upload_as_links, remote_files_map)
         self._key_id_map: KeyIdMap = None
@@ -114,7 +126,9 @@ class VideoConverter(BaseConverter):
         existing_names = set([vid.name for vid in api.video.get_list(dataset_id)])
 
         # check video codecs, mimetypes and convert if needed
-        convert_progress, convert_progress_cb = self.get_progress(self.items_count, "Preparing videos...")
+        convert_progress, convert_progress_cb = self.get_progress(
+            self.items_count, "Preparing videos..."
+        )
         for item in self._items:
             item_name, item_path = self.convert_to_mp4_if_needed(item.path)
             item.name = item_name
@@ -124,11 +138,14 @@ class VideoConverter(BaseConverter):
             convert_progress.close()
 
         has_large_files = False
+        size_progress_cb = None
         progress_cb, progress, ann_progress, ann_progress_cb = None, None, None, None
         if log_progress and not self.upload_as_links:
             progress, progress_cb = self.get_progress(self.items_count, "Uploading videos...")
             file_sizes = [get_file_size(item.path) for item in self._items]
-            has_large_files = any([self._check_video_file_size(file_size) for file_size in file_sizes])
+            has_large_files = any(
+                [self._check_video_file_size(file_size) for file_size in file_sizes]
+            )
             if has_large_files:
                 upload_progress = []
                 size_progress_cb = self._get_video_upload_progress(upload_progress)
@@ -146,17 +163,19 @@ class VideoConverter(BaseConverter):
                 item_paths.append(item.path)
                 item_names.append(item.name)
 
-                if not self.upload_as_links:
-                    # TODO: implement generating annotations for remote videos
+                ann = None
+                if not self.upload_as_links or self.supports_links:
                     ann = self.to_supervisely(item, meta, renamed_classes, renamed_tags)
-                    figures_cnt += len(ann.figures)
-                    anns.append(ann)
+                    if ann is not None:
+                        figures_cnt += len(ann.figures)
+                anns.append(ann)
 
             if self.upload_as_links:
                 vid_infos = api.video.upload_links(
                     dataset_id,
                     item_paths,
                     item_names,
+                    skip_download=True,
                 )
             else:
                 vid_infos = api.video.upload_paths(
@@ -164,22 +183,24 @@ class VideoConverter(BaseConverter):
                     item_names,
                     item_paths,
                     progress_cb=progress_cb if log_progress else None,
-                    item_progress=size_progress_cb if log_progress and has_large_files else None, # pylint: disable=used-before-assignment
+                    item_progress=(size_progress_cb if log_progress and has_large_files else None),
                 )
-                vid_ids = [vid_info.id for vid_info in vid_infos]
+            vid_ids = [vid_info.id for vid_info in vid_infos]
 
-                if log_progress and has_large_files and figures_cnt > 0:
-                    ann_progress, ann_progress_cb = self.get_progress(figures_cnt, "Uploading annotations...")
+            if log_progress and has_large_files and figures_cnt > 0:
+                ann_progress, ann_progress_cb = self.get_progress(
+                    figures_cnt, "Uploading annotations..."
+                )
 
-                for video_id, ann in zip(vid_ids, anns):
-                    if ann is None:
-                        ann = VideoAnnotation(item.shape, item.frame_count)
-                    api.video.annotation.append(video_id, ann, progress_cb=ann_progress_cb)
+            for vid, ann, item, info in zip(vid_ids, anns, batch, vid_infos):
+                if ann is None:
+                    ann = VideoAnnotation((info.frame_height, info.frame_width), info.frames_count)
+                api.video.annotation.append(vid, ann, progress_cb=ann_progress_cb)
 
         if log_progress and is_development():
-            if progress is not None: # pylint: disable=possibly-used-before-assignment
+            if progress is not None:
                 progress.close()
-            if not self.upload_as_links and ann_progress is not None:
+            if ann_progress is not None:
                 ann_progress.close()
         logger.info(f"Dataset ID:{dataset_id} has been successfully uploaded.")
 
@@ -268,7 +289,7 @@ class VideoConverter(BaseConverter):
         )
 
     def _check_video_file_size(self, file_size):
-        return file_size > 20 * 1024 * 1024 # 20 MB
+        return file_size > 20 * 1024 * 1024  # 20 MB
 
     def _get_video_upload_progress(self, upload_progress):
         upload_progress = []