supervisely 6.73.247__py3-none-any.whl → 6.73.248__py3-none-any.whl

supervisely/api/annotation_api.py

@@ -1418,13 +1418,14 @@ class AnnotationApi(ModuleApi):
             # 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(
+                figures = await self._api.image.figure.download_geometries_batch_async(
                     figure_ids,
                     (
                         progress_cb
                         if progress_cb is not None and progress_cb_type == "size"
                         else None
                     ),
+                    semaphore=semaphore,
                 )
                 for figure_id, geometry in zip(figure_ids, figures):
                     label_idx = additonal_geometries[figure_id]
@@ -1515,3 +1516,131 @@ class AnnotationApi(ModuleApi):
             tasks.append(task)
         ann_infos = await asyncio.gather(*tasks)
         return ann_infos
+
+    async def download_bulk_async(
+        self,
+        dataset_id: int,
+        image_ids: List[int],
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        with_custom_data: Optional[bool] = False,
+        force_metadata_for_links: Optional[bool] = True,
+        semaphore: Optional[asyncio.Semaphore] = None,
+    ) -> List[AnnotationInfo]:
+        """
+        Get list of AnnotationInfos for given dataset ID from API.
+        This method is optimized for downloading a large number of small size annotations with a single API call.
+
+        :param dataset_id: Dataset ID in Supervisely.
+        :type dataset_id: int
+        :param image_ids: List of integers.
+        :type image_ids: List[int]
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: tqdm
+        :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 semaphore: Semaphore for limiting the number of simultaneous downloads.
+        :type semaphore: asyncio.Semaphore, 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]
+            p = tqdm(desc="Annotations downloaded: ", total=len(image_ids))
+
+            ann_infos = await api.annotation.download_bulk_async(dataset_id, image_ids, progress_cb=p)
+
+            Optimizing the download process by using the context to avoid redundant API calls.:
+            # 1. Download the project meta
+            project_id = api.dataset.get_info_by_id(dataset_id).project_id
+            project_meta = api.project.get_meta(project_id)
+
+            # 2. Use the context to avoid redundant API calls
+            dataset_id = 254737
+            image_ids = [121236918, 121236919]
+            with sly.ApiContext(api, dataset_id=dataset_id, project_id=project_id, project_meta=project_meta):
+                ann_infos = await api.annotation.download_bulk_async(dataset_id, image_ids)
+        """
+        if semaphore is None:
+            semaphore = self._api.get_default_semaphore()
+
+        # 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
+
+        need_download_alpha_masks = False
+        for obj_cls in project_meta.obj_classes:
+            if obj_cls.geometry_type == AlphaMask:
+                need_download_alpha_masks = True
+                break
+
+        id_to_ann = {}
+        for batch in batched(image_ids):
+            json_data = {
+                ApiField.DATASET_ID: dataset_id,
+                ApiField.IMAGE_IDS: batch,
+                ApiField.WITH_CUSTOM_DATA: with_custom_data,
+                ApiField.FORCE_METADATA_FOR_LINKS: force_metadata_for_links,
+                ApiField.INTEGER_COORDS: False,
+            }
+            async with semaphore:
+                results = await self._api.post_async("annotations.bulk.info", json=json_data)
+                results = results.json()
+            if need_download_alpha_masks is True:
+                additonal_geometries = defaultdict(tuple)
+                for ann_idx, ann_dict in enumerate(results):
+                    # check if there are any AlphaMask geometries in the batch
+                    for label_idx, label in enumerate(
+                        ann_dict[ApiField.ANNOTATION][AnnotationJsonFields.LABELS]
+                    ):
+                        if label[LabelJsonFields.GEOMETRY_TYPE] == AlphaMask.geometry_name():
+                            figure_id = label[LabelJsonFields.ID]
+                            additonal_geometries[figure_id] = (ann_idx, label_idx)
+
+                # if there are any AlphaMask geometries, download them separately and update the annotation
+                if len(additonal_geometries) > 0:
+                    figure_ids = list(additonal_geometries.keys())
+                    figures = await self._api.image.figure.download_geometries_batch_async(
+                        figure_ids, semaphore=semaphore
+                    )
+                    for figure_id, geometry in zip(figure_ids, figures):
+                        ann_idx, label_idx = additonal_geometries[figure_id]
+                        results[ann_idx][ApiField.ANNOTATION][AnnotationJsonFields.LABELS][
+                            label_idx
+                        ].update({BITMAP: geometry})
+
+            for ann_dict in results:
+                # Convert annotation to pixel coordinate system
+                ann_dict[ApiField.ANNOTATION] = Annotation._to_pixel_coordinate_system_json(
+                    ann_dict[ApiField.ANNOTATION]
+                )
+                ann_info = self._convert_json_info(ann_dict)
+                id_to_ann[ann_info.image_id] = ann_info
+
+            if progress_cb is not None:
+                progress_cb(len(batch))
+        ordered_results = [id_to_ann[image_id] for image_id in image_ids]
+        return ordered_results

supervisely/api/api.py

@@ -1437,7 +1437,7 @@ class Api:
         :type range_start: int, optional
         :param range_end: End byte position for streaming.
         :type range_end: int, optional
-        :param chunk_size: Size of the chunk to read from the stream.
+        :param chunk_size: Size of the chunk to read from the stream. Default is 8192.
         :type chunk_size: int, optional
         :param use_public_api: Define if public API should be used.
         :type use_public_api: bool, optional

supervisely/api/entity_annotation/figure_api.py

@@ -3,10 +3,21 @@
 # docs
 from __future__ import annotations
 
+import asyncio
 import json
 import re
 from collections import defaultdict
-from typing import Callable, Dict, Generator, List, NamedTuple, Optional, Tuple, Union
+from typing import (
+    AsyncGenerator,
+    Callable,
+    Dict,
+    Generator,
+    List,
+    NamedTuple,
+    Optional,
+    Tuple,
+    Union,
+)
 
 import numpy as np
 from requests_toolbelt import MultipartDecoder, MultipartEncoder
@@ -608,3 +619,81 @@ class FigureApi(RemoveableBulkModuleApi):
                 )
             encoder = MultipartEncoder(fields=fields)
             self._api.post("figures.bulk.upload.geometry", encoder)
+
+    async def _download_geometries_generator_async(
+        self, ids: List[int], semaphore: Optional[asyncio.Semaphore] = None
+    ) -> AsyncGenerator[Tuple[int, bytes], None, None]:
+        """
+        Private method. Download figures geometries with given IDs from storage asynchronously.
+
+        :param ids: List of figure IDs in Supervisely.
+        :type ids: List[int]
+        :return: Async generator with pairs of figure ID and figure geometry.
+        :rtype: AsyncGenerator[Tuple[int, bytes], None, None]
+        """
+        if semaphore is None:
+            semaphore = self._api.get_default_semaphore()
+
+        for batch_ids in batched(ids):
+            async with semaphore:
+                response = await self._api.post_async(
+                    "figures.bulk.download.geometry", {ApiField.IDS: batch_ids}
+                )
+            decoder = MultipartDecoder.from_response(response)
+            for part in decoder.parts:
+                content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
+                # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
+                # The regex has 2 capture group: one for the prefix and one for the actual name value.
+                figure_id = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
+                yield figure_id, part.content
+
+    async def download_geometries_batch_async(
+        self,
+        ids: List[int],
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        semaphore: Optional[asyncio.Semaphore] = None,
+    ) -> List[dict]:
+        """
+        Download figure geometries with given IDs from storage asynchronously.
+
+        :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
+        :param semaphore: Semaphore to limit the number of concurrent downloads.
+        :type semaphore: Optional[asyncio.Semaphore], optional
+        :return: List of figure geometries in Supervisely JSON format.
+        :rtype: List[dict]
+
+        :Usage example:
+
+            .. code-block:: python
+
+                import asyncio
+                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()
+
+                figure_ids = [642155547, 642155548, 642155549]
+                loop = sly.utils.get_or_create_event_loop()
+                geometries = loop.run_until_complete(
+                    api.figure.download_geometries_batch_async(
+                        figure_ids,
+                        progress_cb=tqdm(total=len(figure_ids), desc="Downloading geometries"),
+                        semaphore=asyncio.Semaphore(15),
+                    )
+                )
+        """
+        geometries = {}
+        async for idx, part in self._download_geometries_generator_async(ids, semaphore):
+            if progress_cb is not None:
+                progress_cb(len(part))
+            geometry_json = json.loads(part)
+            geometries[idx] = geometry_json
+
+        if len(geometries) != len(ids):
+            raise RuntimeError("Not all geometries were downloaded")
+        ordered_results = [geometries[i] for i in ids]
+        return ordered_results

supervisely/api/image_api.py

@@ -13,6 +13,7 @@ from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from functools import partial
+from math import ceil
 from pathlib import Path
 from time import sleep
 from typing import (
@@ -3705,11 +3706,12 @@ class ImageApi(RemoveableBulkModuleApi):
         range_start: Optional[int] = None,
         range_end: Optional[int] = None,
         headers: Optional[dict] = None,
+        chunk_size: Optional[int] = None,
     ) -> AsyncGenerator:
         """
         Download Image 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.
+        For streaming, returns tuple of chunk and hash. Chunk size is 8 MB by default.
 
         :param id: Image ID in Supervisely.
         :type id: int
@@ -3721,11 +3723,16 @@ class ImageApi(RemoveableBulkModuleApi):
         :type range_end: int, optional
         :param headers: Headers for request.
         :type headers: dict, optional
+        :param chunk_size: Size of chunk for streaming. Default is 8 MB.
+        :type chunk_size: int, optional
         :return: Stream of bytes or response object.
         :rtype: AsyncGenerator
         """
         api_method_name = "images.download"
 
+        if chunk_size is None:
+            chunk_size = 8 * 1024 * 1024
+
         json_body = {ApiField.ID: id}
 
         if is_stream:
@@ -3736,6 +3743,7 @@ class ImageApi(RemoveableBulkModuleApi):
                 headers=headers,
                 range_start=range_start,
                 range_end=range_end,
+                chunk_size=chunk_size,
             ):
                 yield chunk, hhash
         else:
@@ -4157,3 +4165,180 @@ class ImageApi(RemoveableBulkModuleApi):
             tasks.append(task)
         results = await asyncio.gather(*tasks)
         return results
+
+    async def download_bytes_generator_async(
+        self,
+        dataset_id: int,
+        img_ids: List[int],
+        semaphore: Optional[asyncio.Semaphore] = None,
+        headers: Optional[dict] = None,
+        check_hash: bool = False,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+        progress_cb_type: Literal["number", "size"] = "number",
+    ) -> AsyncGenerator[Tuple[int, bytes]]:
+        """
+        Downloads Image bytes with given ID in batch asynchronously.
+        Yields tuple of Image ID and bytes of downloaded image.
+        Uses bulk download API method.
+
+        :param dataset_id: Dataset ID in Supervisely.
+        :type dataset_id: int
+        :param img_ids: List of Image IDs in Supervisely.
+        :type img_ids: :class:`List[int]`
+        :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 check_hash: If True, checks hash of downloaded bytes. Default is False.
+        :type check_hash: bool, optional
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: Optional[Union[tqdm, Callable]]
+        :param progress_cb_type: Type of progress callback. Can be "number" or "size". Default is "number".
+        :type progress_cb_type: Literal["number", "size"], optional
+        :return: Tuple of Image ID and bytes of downloaded image.
+        :rtype: :class:`Tuple[int, bytes]`
+
+        :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()
+
+            dataset_id = 123456
+            img_ids = [770918, 770919, 770920, 770921, ... , 770992]
+            tasks = []
+            for batch in batched(img_ids, 50):
+                task = api.image.download_bytes_batch_async(dataset_id, batch)
+                tasks.append(task)
+            results = await asyncio.gather(*tasks)
+        """
+        api_method_name = "images.bulk.download"
+        json_body = {
+            ApiField.DATASET_ID: dataset_id,
+            ApiField.IMAGE_IDS: img_ids,
+        }
+
+        if semaphore is None:
+            semaphore = self._api.get_default_semaphore()
+        async with semaphore:
+            response = await self._api.post_async(
+                api_method_name,
+                json=json_body,
+                headers=headers,
+            )
+        decoder = MultipartDecoder.from_response(response)
+        for part in decoder.parts:
+            content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
+            # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
+            # The regex has 2 capture group: one for the prefix and one for the actual name value.
+            img_id = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
+            if check_hash:
+                hhash = part.headers.get("x-content-checksum-sha256", None)
+                if hhash is not None:
+                    downloaded_bytes_hash = get_bytes_hash(part)
+                    if hhash != downloaded_bytes_hash:
+                        raise RuntimeError(
+                            f"Downloaded hash of image with ID:{img_id} does not match the expected hash: {downloaded_bytes_hash} != {hhash}"
+                        )
+            if progress_cb is not None and progress_cb_type == "number":
+                progress_cb(1)
+            elif progress_cb is not None and progress_cb_type == "size":
+                progress_cb(len(part.content))
+
+            yield img_id, part.content
+
+    async def get_list_generator_async(
+        self,
+        dataset_id: int = None,
+        filters: Optional[List[Dict[str, str]]] = None,
+        sort: Optional[str] = "id",
+        sort_order: Optional[str] = "asc",
+        force_metadata_for_links: Optional[bool] = True,
+        only_labelled: Optional[bool] = False,
+        fields: Optional[List[str]] = None,
+        per_page: Optional[int] = 500,
+        semaphore: Optional[List[asyncio.Semaphore]] = None,
+        **kwargs,
+    ) -> AsyncGenerator[List[ImageInfo]]:
+        """
+        Yields list of images in dataset asynchronously page by page.
+
+        :param dataset_id: Dataset ID in Supervisely.
+        :type dataset_id: int
+        :param filters: Filters for images.
+        :type filters: List[Dict[str, str]], optional
+        :param sort: Sort images by field.
+        :type sort: str, optional
+        :param sort_order: Sort order for images.
+        :type sort_order: str, optional
+        :param force_metadata_for_links: If True, forces metadata for links.
+        :type force_metadata_for_links: bool, optional
+        :param only_labelled: If True, returns only labelled images.
+        :type only_labelled: bool, optional
+        :param fields: List of fields to return.
+        :type fields: List[str], optional
+        :param per_page: Number of images to return per page.
+        :type per_page: int, optional
+        :param semaphore: Semaphore for limiting the number of simultaneous requests.
+        :type semaphore: :class:`asyncio.Semaphore`, optional
+        :param kwargs: Additional arguments.
+        :return: List of images in dataset.
+        :rtype: AsyncGenerator[List[ImageInfo]]
+
+        :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()
+
+                    loop = sly.utils.get_or_create_event_loop()
+                    images = loop.run_until_complete(api.image.get_list_async(123456, per_page=600))
+        """
+
+        method = "images.list"
+        dataset_info = kwargs.get("dataset_info", None)
+
+        if dataset_info is None:
+            dataset_info = self._api.dataset.get_info_by_id(dataset_id, raise_error=True)
+
+        total_pages = ceil(dataset_info.items_count / per_page)
+
+        data = {
+            ApiField.DATASET_ID: dataset_info.id,
+            ApiField.PROJECT_ID: dataset_info.project_id,
+            ApiField.SORT: sort,
+            ApiField.SORT_ORDER: sort_order,
+            ApiField.FORCE_METADATA_FOR_LINKS: force_metadata_for_links,
+            ApiField.FILTER: filters or [],
+            ApiField.PER_PAGE: per_page,
+        }
+        if fields is not None:
+            data[ApiField.FIELDS] = fields
+        if only_labelled:
+            data[ApiField.FILTERS] = [
+                {
+                    "type": "objects_class",
+                    "data": {
+                        "from": 1,
+                        "to": 9999,
+                        "include": True,
+                        "classId": None,
+                    },
+                }
+            ]
+
+        if semaphore is None:
+            semaphore = self._api.get_default_semaphore()
+
+        async for page in self.get_list_page_generator_async(method, data, total_pages, semaphore):
+            yield page

supervisely/api/module_api.py

@@ -1,7 +1,9 @@
 # coding: utf-8
+import asyncio
 from collections import namedtuple
 from copy import deepcopy
-from typing import TYPE_CHECKING, List
+from math import ceil
+from typing import TYPE_CHECKING, Any, AsyncGenerator, List, NamedTuple, Optional, Tuple
 
 import requests
 
@@ -867,6 +869,98 @@ class ModuleApiBase(_JsonConvertibleModule):
         response = self._get_response_by_id(id, method, id_field=ApiField.ID, fields=fields)
         return self._convert_json_info(response.json()) if (response is not None) else None
 
+    async def get_list_idx_page_async(
+        self,
+        method: str,
+        data: dict,
+    ) -> Tuple[int, List[NamedTuple]]:
+        """
+        Get the list of items for a given page number.
+        Page number is specified in the data dictionary.
+
+        :param method: Method to call for listing items.
+        :type method: str
+        :param data: Data to pass to the API method.
+        :type data: dict
+        :return: List of items.
+        :rtype: Tuple[int, List[NamedTuple]]
+        """
+
+        response = await self._api.post_async(method, data)
+        response_json = response.json()
+        entities = response_json.get("entities", [])
+        # To avoid empty pages when a filter is applied to the data and the `pagesCount` is less than the number calculated based on the items and `per_page` size.
+        # Process `pagesCount` in the main function according to the actual number of pages returned.
+        pages_count = response_json.get("pagesCount", None)
+        if pages_count is None:
+            raise ValueError("Can not determine the number of pages to retrieve.")
+        return pages_count, [self._convert_json_info(item) for item in entities]
+
+    async def get_list_page_generator_async(
+        self,
+        method: str,
+        data: dict,
+        pages_count: Optional[int] = None,
+        semaphore: Optional[List[asyncio.Semaphore]] = None,
+    ) -> AsyncGenerator[List[Any], None]:
+        """
+        Yields list of images in dataset asynchronously page by page.
+
+        :param method: Method to call for listing items.
+        :type method: str
+        :param data: Data to pass to the API method.
+        :type data: dict
+        :param pages_count: Preferred number of pages to retrieve if used with a `per_page` limit.
+                            Will be automatically adjusted if the `pagesCount` differs from the requested number.
+        :type pages_count: int, optional
+        :param semaphore: Semaphore for limiting the number of simultaneous requests.
+        :type semaphore: :class:`asyncio.Semaphore`, optional
+        :param kwargs: Additional arguments.
+        :return: List of images in dataset.
+        :rtype: AsyncGenerator[List[ImageInfo]]
+
+        :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()
+
+                    method = 'images.list'
+                    data = {
+                        'datasetId': 123456
+                    }
+
+                    loop = sly.utils.get_or_create_event_loop()
+                    images = loop.run_until_complete(api.image.get_list_generator_async(method, data))
+        """
+
+        if semaphore is None:
+            semaphore = self._api.get_default_semaphore()
+
+        async def sem_task(task):
+            async with semaphore:
+                return await task
+
+        if pages_count is None:
+            pages_count = 999999  # to avoid range lesser than total pages count
+        for page_num in range(1, pages_count + 1):
+            if page_num <= pages_count:
+                data[ApiField.PAGE] = page_num
+                total_pages, items = await sem_task(self.get_list_idx_page_async(method, data))
+
+                # To correct `total_pages` count in case filter is applied
+                if page_num == 1:
+                    pages_count = total_pages
+
+                yield items
+            else:
+                break
+
 
 class ModuleApi(ModuleApiBase):
     """Base class for entities that have a parent object in the system."""

supervisely/nn/benchmark/utils/semantic_segmentation/utils.py

@@ -1,6 +1,5 @@
 import cv2
 import numpy as np
-import scipy
 
 
 def one_hot(segmentation, num_classes):
@@ -18,12 +17,16 @@ def single_one_hot(segmentation, cls):
 
 
 def get_single_contiguous_segment(one_hot_segmentation):
+    import scipy  # pylint: disable=import-error
+
     kernel = np.ones((3, 3), dtype=one_hot_segmentation.dtype)
     seg = scipy.ndimage.label(one_hot_segmentation, structure=kernel)[0]
     return [np.where(seg == l) for l in range(1, seg.max() + 1)]
 
 
 def get_contiguous_segments(one_hot_segmentation):
+    import scipy  # pylint: disable=import-error
+
     kernel = np.ones((3, 3), dtype=one_hot_segmentation.dtype)
     segments_tensor = np.stack(
         [scipy.ndimage.label(seg, structure=kernel)[0] for seg in one_hot_segmentation]

supervisely/nn/tracker/deep_sort/deep_sort/kalman_filter.py

@@ -1,7 +1,5 @@
 # vim: expandtab:ts=4:sw=4
 import numpy as np
-import scipy.linalg
-
 
 """
 Table for the 0.95 quantile of the chi-square distribution with N degrees of
@@ -171,6 +169,8 @@ class KalmanFilter(object):
             Returns the measurement-corrected state distribution.
 
         """
+        import scipy.linalg  # pylint: disable=import-error
+
         projected_mean, projected_cov = self.project(mean, covariance)
 
         chol_factor, lower = scipy.linalg.cho_factor(
@@ -215,6 +215,8 @@ class KalmanFilter(object):
             `measurements[i]`.
 
         """
+        import scipy.linalg  # pylint: disable=import-error
+
         mean, covariance = self.project(mean, covariance)
         if only_position:
             mean, covariance = mean[:2], covariance[:2, :2]

supervisely/nn/tracker/utils/kalman_filter.py

@@ -1,5 +1,4 @@
 import numpy as np
-import scipy.linalg
 
 """
 Table for the 0.95 quantile of the chi-square distribution with N degrees of
@@ -215,6 +214,8 @@ class KalmanFilterXYWH(object):
             Returns the measurement-corrected state distribution.
 
         """
+        import scipy.linalg  # pylint: disable=import-error
+
         projected_mean, projected_cov = self.project(mean, covariance)
 
         chol_factor, lower = scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
@@ -254,6 +255,8 @@ class KalmanFilterXYWH(object):
             squared Mahalanobis distance between (mean, covariance) and
             `measurements[i]`.
         """
+        import scipy.linalg  # pylint: disable=import-error
+
         mean, covariance = self.project(mean, covariance)
         if only_position:
             mean, covariance = mean[:2], covariance[:2, :2]
@@ -428,6 +431,8 @@ class KalmanFilterXYAH(object):
             Returns the measurement-corrected state distribution.
 
         """
+        import scipy.linalg  # pylint: disable=import-error
+
         projected_mean, projected_cov = self.project(mean, covariance)
 
         chol_factor, lower = scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
@@ -471,6 +476,8 @@ class KalmanFilterXYAH(object):
             `measurements[i]`.
 
         """
+        import scipy.linalg  # pylint: disable=import-error
+
         mean, covariance = self.project(mean, covariance)
         if only_position:
             mean, covariance = mean[:2], covariance[:2, :2]

supervisely/project/download.py

@@ -225,31 +225,51 @@ def download_async_or_sync(
     semaphore: Optional[asyncio.Semaphore] = None,
     **kwargs,
 ):
-    project_info = api.project.get_info_by_id(project_id)
+    """
+    Download project asynchronously if possible, otherwise download synchronously.
+    Automatically detects project type.
+    You can pass :class:`ProjectInfo` as `project_info` kwarg to avoid additional API requests.
+
+    In case of error during asynchronous download, the function will switch to synchronous download.
+    """
+    project_info = kwargs.pop("project_info", None)
+    if not isinstance(project_info, ProjectInfo) or project_info.id != project_id:
+        project_info = api.project.get_info_by_id(project_id)
 
     if progress_cb is not None:
         log_progress = False
 
     project_class = get_project_class(project_info.type)
-    if hasattr(project_class, "download_async"):
-        download_coro = project_class.download_async(
-            api=api,
-            project_id=project_id,
-            dest_dir=dest_dir,
-            semaphore=semaphore,
-            dataset_ids=dataset_ids,
-            log_progress=log_progress,
-            progress_cb=progress_cb,
-            **kwargs,
-        )
-        loop = get_or_create_event_loop()
-        if loop.is_running():
-            future = asyncio.run_coroutine_threadsafe(download_coro, loop=loop)
-            future.result()
-        else:
-            loop.run_until_complete(download_coro)
 
+    switch_to_sync = False
+    if hasattr(project_class, "download_async"):
+        try:
+            download_coro = project_class.download_async(
+                api=api,
+                project_id=project_id,
+                dest_dir=dest_dir,
+                semaphore=semaphore,
+                dataset_ids=dataset_ids,
+                log_progress=log_progress,
+                progress_cb=progress_cb,
+                **kwargs,
+            )
+            loop = get_or_create_event_loop()
+            if loop.is_running():
+                future = asyncio.run_coroutine_threadsafe(download_coro, loop=loop)
+                future.result()
+            else:
+                loop.run_until_complete(download_coro)
+        except Exception as e:
+            if kwargs.get("resume_download", False) is False:
+                remove_dir(dest_dir)
+            logger.error(f"Failed to download project {project_id} asynchronously: {e}")
+            logger.warning("Switching to synchronous download")
+            switch_to_sync = True
     else:
+        switch_to_sync = True
+
+    if switch_to_sync:
         project_class.download(
             api=api,
             project_id=project_id,
@@ -338,7 +358,7 @@ def _validate_dataset(
     project_meta_changed = _project_meta_changed(project_meta, project.meta)
     for dataset in project.datasets:
         dataset: Dataset
-        if dataset.name.endswith(dataset_info.name): # TODO: fix it later
+        if dataset.name.endswith(dataset_info.name):  # TODO: fix it later
             diff = set(items_infos_dict.keys()).difference(set(dataset.get_items_names()))
             if diff:
                 logger.debug(

supervisely/project/project.py

@@ -40,9 +40,9 @@ from supervisely.io.fs import (
     copy_file,
     copy_file_async,
     dir_empty,
-    file_exists,
     dir_exists,
     ensure_base_path,
+    file_exists,
     get_file_name_with_ext,
     list_dir_recursively,
     list_files,
@@ -3434,6 +3434,7 @@ class Project:
         save_image_meta: bool = False,
         images_ids: Optional[List[int]] = None,
         resume_download: Optional[bool] = False,
+        **kwargs,
     ) -> None:
         """
         Download project from Supervisely to the given directory in asynchronous mode.
@@ -3488,6 +3489,12 @@ class Project:
                 else:
                     loop.run_until_complete(coroutine)
         """
+        if kwargs.pop("cache", None) is not None:
+            logger.warning(
+                "Cache is not supported in async mode and will be ignored. "
+                "Use resume_download parameter instead to optimize download process."
+            )
+
         await _download_project_async(
             api=api,
             project_id=project_id,
@@ -3733,7 +3740,8 @@ def _download_project(
                     batch, image_names, batch_imgs_bytes, ann_jsons
                 ):
                     dataset_fs: Dataset
-
+                    # to fix already downloaded images that doesn't have info files
+                    dataset_fs.delete_item(name)
                     dataset_fs.add_item_raw_bytes(
                         item_name=name,
                         item_raw_bytes=img_bytes if save_images is True else None,
@@ -4401,14 +4409,42 @@ async def _download_project_async(
     only_image_tags: Optional[bool] = False,
     save_image_info: Optional[bool] = False,
     save_images: Optional[bool] = True,
-    progress_cb: Optional[Callable] = None,
+    progress_cb: Optional[Union[tqdm, Callable]] = None,
     save_image_meta: Optional[bool] = False,
     images_ids: Optional[List[int]] = None,
     resume_download: Optional[bool] = False,
+    **kwargs,
 ):
+    """
+    Download image project to the local directory asynchronously.
+    Uses queue and semaphore to control the number of parallel downloads.
+    Every image goes through size check to decide if it should be downloaded in bulk or one by one.
+    Checked images are split into two lists: small and large. Small images are downloaded in bulk, large images are downloaded one by one.
+    As soon as the task is created, it is put into the queue. Workers take tasks from the queue and execute them.
+
+    """
+    # to switch between single and bulk download
+    switch_size = kwargs.get("switch_size", 1.28 * 1024 * 1024)
+    # batch size for bulk download
+    batch_size = kwargs.get("batch_size", 100)
+    # number of workers
+    num_workers = kwargs.get("num_workers", 5)
+
     if semaphore is None:
         semaphore = api.get_default_semaphore()
 
+    async def worker(queue: asyncio.Queue, semaphore: asyncio.Semaphore):
+        while True:
+            task = await queue.get()
+            if task is None:
+                break
+            async with semaphore:
+                await task
+            queue.task_done()
+
+    queue = asyncio.Queue()
+    workers = [asyncio.create_task(worker(queue, semaphore)) for _ in range(num_workers)]
+
     dataset_ids = set(dataset_ids) if (dataset_ids is not None) else None
     project_fs = None
     meta = ProjectMeta.from_json(api.project.get_meta(project_id, with_settings=True))
@@ -4448,16 +4484,25 @@ async def _download_project_async(
         force_metadata_for_links = False
         if save_images is False and only_image_tags is True:
             force_metadata_for_links = True
-        all_images = api.image.get_list(
-            dataset_id, force_metadata_for_links=force_metadata_for_links
+        all_images = api.image.get_list_generator_async(
+            dataset_id, force_metadata_for_links=force_metadata_for_links, dataset_info=dataset
         )
-        images = [image for image in all_images if images_ids is None or image.id in images_ids]
+        small_images = []
+        large_images = []
+        async for image_batch in all_images:
+            for image in image_batch:
+                if images_ids is None or image.id in images_ids:
+                    if image.size < switch_size:
+                        small_images.append(image)
+                    else:
+                        large_images.append(image)
 
         ds_progress = progress_cb
         if log_progress is True:
             ds_progress = tqdm_sly(
                 desc="Downloading images from {!r}".format(dataset.name),
-                total=len(images),
+                total=len(small_images) + len(large_images),
+                leave=False,
             )
 
         with ApiContext(
@@ -4466,18 +4511,42 @@ async def _download_project_async(
             dataset_id=dataset_id,
             project_meta=meta,
         ):
-            tasks = []
-            for image in images:
-                try:
-                    existing = dataset_fs.get_item_info(image.name)
-                except:
-                    existing = None
-                else:
-                    if existing.updated_at == image.updated_at:
-                        if ds_progress is not None:
-                            ds_progress(1)
-                        continue
 
+            async def check_items(check_list: List[sly.ImageInfo]):
+                to_download = []
+                for image in check_list:
+                    try:
+                        existing = dataset_fs.get_item_info(image.name)
+                    except:
+                        pass
+                    else:
+                        if existing.updated_at == image.updated_at:
+                            if ds_progress is not None:
+                                ds_progress(1)
+                            continue
+                    to_download.append(image)
+                return to_download
+
+            small_images = await check_items(small_images)
+            large_images = await check_items(large_images)
+            if len(small_images) == 1:
+                large_images.append(small_images.pop())
+            for images_batch in batched(small_images, batch_size=batch_size):
+                task = _download_project_items_batch_async(
+                    api=api,
+                    dataset_id=dataset_id,
+                    img_infos=images_batch,
+                    meta=meta,
+                    dataset_fs=dataset_fs,
+                    id_to_tagmeta=id_to_tagmeta,
+                    semaphore=semaphore,
+                    save_images=save_images,
+                    save_image_info=save_image_info,
+                    only_image_tags=only_image_tags,
+                    progress_cb=ds_progress,
+                )
+                await queue.put(task)
+            for image in large_images:
                 task = _download_project_item_async(
                     api=api,
                     img_info=image,
@@ -4490,11 +4559,15 @@ async def _download_project_async(
                     only_image_tags=only_image_tags,
                     progress_cb=ds_progress,
                 )
-                tasks.append(task)
-            await asyncio.gather(*tasks)
+                await queue.put(task)
+
+        await queue.join()
+
+        all_images = small_images + large_images
+
         if save_image_meta:
             meta_dir = dataset_fs.meta_dir
-            for image_info in images:
+            for image_info in all_images:
                 if image_info.meta:
                     sly.fs.mkdir(meta_dir)
                     sly.json.dump_json_file(
@@ -4506,6 +4579,10 @@ async def _download_project_async(
         for item_name in dataset_fs.get_items_names():
             if item_name not in items_names_set:
                 dataset_fs.delete_item(item_name)
+
+    for _ in range(num_workers):
+        await queue.put(None)
+    await asyncio.gather(*workers)
     try:
         create_readme(dest_dir, project_id, api)
     except Exception as e:
@@ -4557,8 +4634,7 @@ async def _download_project_item_async(
         tmp_ann = Annotation(img_size=(img_info.height, img_info.width), img_tags=tags)
         ann_json = tmp_ann.to_json()
 
-    if dataset_fs.item_exists(img_info.name):
-        dataset_fs.delete_item(img_info.name)
+    dataset_fs.delete_item(img_info.name)
     await dataset_fs.add_item_raw_bytes_async(
         item_name=img_info.name,
         item_raw_bytes=img_bytes if save_images is True else None,
@@ -4569,4 +4645,78 @@ async def _download_project_item_async(
         progress_cb(1)
 
 
+async def _download_project_items_batch_async(
+    api: sly.Api,
+    dataset_id: int,
+    img_infos: List[sly.ImageInfo],
+    meta: ProjectMeta,
+    dataset_fs: Dataset,
+    id_to_tagmeta: Dict[int, sly.TagMeta],
+    semaphore: asyncio.Semaphore,
+    save_images: bool,
+    save_image_info: bool,
+    only_image_tags: bool,
+    progress_cb: Optional[Callable],
+):
+    """
+    Download images and annotations from Supervisely API and save them to the local filesystem.
+    Uses parameters from the parent function _download_project_async.
+    It is used for batch download of images and annotations with the bulk download API methods.
+    """
+    if save_images:
+        img_ids = [img_info.id for img_info in img_infos]
+        imgs_bytes = [None] * len(img_ids)
+        temp_dict = {}
+        async for img_id, img_bytes in api.image.download_bytes_generator_async(
+            dataset_id,
+            img_ids,
+            semaphore=semaphore,
+            check_hash=True,
+        ):
+            temp_dict[img_id] = img_bytes
+        # to be sure that the order is correct
+        for idx, img_id in enumerate(img_ids):
+            imgs_bytes[idx] = temp_dict[img_id]
+        for img_info, img_bytes in zip(img_infos, imgs_bytes):
+            if None in [img_info.height, img_info.width]:
+                width, height = sly.image.get_size_from_bytes(img_bytes)
+                img_info = img_info._replace(height=height, width=width)
+    else:
+        imgs_bytes = [None] * len(img_infos)
+
+    if only_image_tags is False:
+        ann_infos = await api.annotation.download_bulk_async(
+            dataset_id,
+            img_ids,
+            semaphore=semaphore,
+            force_metadata_for_links=not save_images,
+        )
+        tmps_anns = [Annotation.from_json(ann_info.annotation, meta) for ann_info in ann_infos]
+        ann_jsons = []
+        for tmp_ann in tmps_anns:
+            if None in tmp_ann.img_size:
+                tmp_ann = tmp_ann.clone(img_size=(img_info.height, img_info.width))
+            ann_jsons.append(tmp_ann.to_json())
+    else:
+        ann_jsons = []
+        for img_info in img_infos:
+            tags = TagCollection.from_api_response(
+                img_info.tags,
+                meta.tag_metas,
+                id_to_tagmeta,
+            )
+            tmp_ann = Annotation(img_size=(img_info.height, img_info.width), img_tags=tags)
+            ann_jsons.append(tmp_ann.to_json())
+    for img_info, ann_json, img_bytes in zip(img_infos, ann_jsons, imgs_bytes):
+        dataset_fs.delete_item(img_info.name)
+        await dataset_fs.add_item_raw_bytes_async(
+            item_name=img_info.name,
+            item_raw_bytes=img_bytes,
+            ann=dataset_fs.get_ann(img_info.name, meta) if ann_json is None else ann_json,
+            img_info=img_info if save_image_info is True else None,
+        )
+        if progress_cb is not None:
+            progress_cb(1)
+
+
 DatasetDict = Project.DatasetDict

{supervisely-6.73.247.dist-info → supervisely-6.73.248.dist-info}/METADATA

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

{supervisely-6.73.247.dist-info → supervisely-6.73.248.dist-info}/RECORD

@@ -21,18 +21,18 @@ supervisely/annotation/tag_meta_mapper.py,sha256=RWeTrxJ64syodyhXIRSH007bX6Hr3B4
 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=s9kd1G759R8YSvbDcNXrPa9xv95j1cWE1RgD6XeJe2A,58826
-supervisely/api/api.py,sha256=SI7DuSi2Jnj5NFS_V9aQ9Sg3CrS97Y5p1pqeeb-4Jb4,64729
+supervisely/api/annotation_api.py,sha256=kB9l0NhQEkunGDC9fWjNzf5DdhqRF1tv-RRnIbkV2k0,64941
+supervisely/api/api.py,sha256=aSFD2Q05q0CK9nmMyFTEv5pHKyTm_ysu9cagwt4GDhs,64746
 supervisely/api/app_api.py,sha256=-T4sISQ7POyR2yirf1kEWj4JaJFpJxCyRWqbf_99Jak,67036
 supervisely/api/dataset_api.py,sha256=2-SQBlgEnIN-0uvDbtPlSXr6ztBeZ3WPryhkOtpBmk4,40786
 supervisely/api/file_api.py,sha256=c4iIzH2BF8-GLFLk_wc9Qz225AbHhbzH22wv5HdsGg4,83128
 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=_wXn10tKKCcfvTiQax0O2X9lnE54nXucwQHTjA1WbRM,169172
+supervisely/api/image_api.py,sha256=2cki-IzA5jnN3QqqdSIbIbHJhDWxFGYxXY94WqBOoio,176836
 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=odnzZjp29yM16Gq-FYkv-OA4WFMNJCLFo4qSikW2A7c,56280
-supervisely/api/module_api.py,sha256=nFMvROP7XB6_BVSsP9W_eEKiTlcGYxezyMCV4pdqk8k,39410
+supervisely/api/module_api.py,sha256=ajVPU5bH1sB-l2PwWq_xtFxSmZIBikflousOxiAYmW4,43141
 supervisely/api/neural_network_api.py,sha256=ktPVRO4Jeulougio8F0mioJJHwRJcX250Djp1wBoQ9c,7620
 supervisely/api/object_class_api.py,sha256=-rQcKwhBw3iL9KNH9c1ROgoimgWM1ls6Wi_tb1R-MzY,7683
 supervisely/api/plugin_api.py,sha256=TlfrosdRuYG4NUxk92QiQoVaOdztFspPpygyVa3M3zk,5283
@@ -49,7 +49,7 @@ supervisely/api/video_annotation_tool_api.py,sha256=Uy1MvT-M7vjC6y-0-V4wFCO-fZt8
 supervisely/api/workspace_api.py,sha256=5KAxpI9DKBmgF_pyQaXHpGT30HZ9wRtR6DP3FoYFZtY,9228
 supervisely/api/entity_annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/api/entity_annotation/entity_annotation_api.py,sha256=K79KdDyepQv4FiNQHBj9V4-zLIemxK9WG1ig1bfBKb8,3083
-supervisely/api/entity_annotation/figure_api.py,sha256=WgeB6h8ZQsgeORXnEAq2LCCezLIMeVibetFTC1PxQM8,20896
+supervisely/api/entity_annotation/figure_api.py,sha256=_JS1x0jn5neoCnZCBKHUBwspoHg92N-sJ9Ty9h07Mvg,24427
 supervisely/api/entity_annotation/object_api.py,sha256=gbcNvN_KY6G80Me8fHKQgryc2Co7VU_kfFd1GYILZ4E,8875
 supervisely/api/entity_annotation/tag_api.py,sha256=M-28m9h8R4k9Eqo6P1S0UH8_D5kqCwAvQLYY6_Yz4oM,11161
 supervisely/api/pointcloud/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -814,7 +814,7 @@ supervisely/nn/benchmark/utils/semantic_segmentation/__init__.py,sha256=47DEQpj8
 supervisely/nn/benchmark/utils/semantic_segmentation/calculate_metrics.py,sha256=4ifC5r_Q880yIr8gWnjEzwKbS0vizMWqSF4XeyaMvh0,924
 supervisely/nn/benchmark/utils/semantic_segmentation/evaluator.py,sha256=R1U_mnOiUUH6P87xiKalYqMpj1uGCJKuOBcsTmVHawY,32894
 supervisely/nn/benchmark/utils/semantic_segmentation/loader.py,sha256=_5ZZ7Nkd8WWYJnKwc1Dx3bEPS_1R84gG_hQc0w0TXWw,1957
-supervisely/nn/benchmark/utils/semantic_segmentation/utils.py,sha256=nV9T7PCUxOdipFIBPrpdwLJXs0GJNp_Eft2MJmrKJRM,3787
+supervisely/nn/benchmark/utils/semantic_segmentation/utils.py,sha256=X5NiR02R-0To2_SuSGHZZccl_-Bupg5F9d7nziIMRMc,3874
 supervisely/nn/benchmark/visualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/nn/benchmark/visualization/evaluation_result.py,sha256=733HJL4rJa5XqCJydW9vSyaepvpHzym9wQsw1wFEgeI,10251
 supervisely/nn/benchmark/visualization/renderer.py,sha256=qxWUYu2glTqksxI5UG08nwDmZA4A2bfGb1wk9DaDct8,3340
@@ -931,14 +931,14 @@ supervisely/nn/tracker/deep_sort/sly_tracker.py,sha256=uhOiwJMt7kh53X_zeWecSm6f3
 supervisely/nn/tracker/deep_sort/deep_sort/__init__.py,sha256=RleTF3kMKdZteclPHRm7E49pw1I1GlooqToAv3YmBd0,27
 supervisely/nn/tracker/deep_sort/deep_sort/detection.py,sha256=cS7YqK8RPbr7C3l6myKTHGBvQbYoKxnEyVa4ZGVbsLY,1430
 supervisely/nn/tracker/deep_sort/deep_sort/iou_matching.py,sha256=HSzn9FjOSHrqH9h6qJlYe1i4o0ZJhjERxCcuIYnLmPE,2830
-supervisely/nn/tracker/deep_sort/deep_sort/kalman_filter.py,sha256=-pPoynyPcJd8p6D-C1WTZczxpz4-bokAzmNM-HtdLcA,7787
+supervisely/nn/tracker/deep_sort/deep_sort/kalman_filter.py,sha256=wDSbs2QA3cnnWB-WAzjNcKKqGiNZmfpN0_Cm9dTxU38,7888
 supervisely/nn/tracker/deep_sort/deep_sort/linear_assignment.py,sha256=hAqMNk2CFPDJvmGJCfNbGVngUgKGM2oYldaGaU2zWC4,7871
 supervisely/nn/tracker/deep_sort/deep_sort/nn_matching.py,sha256=U0NYReianEohMc9eA_eAuXjqMkqkNjWlq40S7VvYKHs,5469
 supervisely/nn/tracker/deep_sort/deep_sort/track.py,sha256=eNvBlhhBcTzyTWOX_TKyT3sWJM6fSz3vPi30kfz8wE4,4976
 supervisely/nn/tracker/deep_sort/deep_sort/tracker.py,sha256=cz--uel4ROLHPem8dOofitCoQj_bTd8srWFp2FpaBR0,5357
 supervisely/nn/tracker/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/nn/tracker/utils/gmc.py,sha256=3JX8979H3NA-YHNaRQyj9Z-xb9qtyMittPEjGw8y2Jo,11557
-supervisely/nn/tracker/utils/kalman_filter.py,sha256=XquwLRFVfZdJMHPqPUtq-kdtuKLY6zgGHbnPGTXL8qU,17044
+supervisely/nn/tracker/utils/kalman_filter.py,sha256=eSFmCjM0mikHCAFvj-KCVzw-0Jxpoc3Cfc2NWEjJC1Q,17268
 supervisely/nn/training/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/nn/training/train_app.py,sha256=E4Qpr9KSEuPLAUJCVUHyt_-tpPQrPRnmpNBGCjnURyw,80464
 supervisely/nn/training/gui/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
@@ -976,10 +976,10 @@ supervisely/pointcloud_episodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 supervisely/pointcloud_episodes/pointcloud_episodes.py,sha256=cRXdtw7bMsbsdVQjxfWxFSESrO-LGiqqsZyyExl2Mbg,3430
 supervisely/project/__init__.py,sha256=hlzdj9Pgy53Q3qdP8LMtGTChvZHQuuShdtui2eRUQeE,2601
 supervisely/project/data_version.py,sha256=nknaWJSUCwoDyNG9_d1KA-GjzidhV9zd9Cn8cg15DOU,19270
-supervisely/project/download.py,sha256=qonvHBiKX-leHW9qWJdyBqFNmpI2_t9s54e68h9orq0,23687
+supervisely/project/download.py,sha256=zb8sb4XZ6Qi3CP7fmtLRUAYzaxs_W0WnOfe2x3ZVRMs,24639
 supervisely/project/pointcloud_episode_project.py,sha256=fcaFAaHVn_VvdiIfHl4IyEFE5-Q3VFGfo7_YoxEma0I,41341
 supervisely/project/pointcloud_project.py,sha256=Y8Xhi6Hg-KyztwFncezuDfKTt2FILss96EU_LdXzmrA,49172
-supervisely/project/project.py,sha256=QRFLDYij18lEOMmcfbpqxeaOHfaz1E5qs5skLEKPQws,182031
+supervisely/project/project.py,sha256=UY7nLGRNcUO6nDvBlirsUg0mbX6XW7_tXoqGaofojqo,188125
 supervisely/project/project_meta.py,sha256=26s8IiHC5Pg8B1AQi6_CrsWteioJP2in00cRNe8QlW0,51423
 supervisely/project/project_settings.py,sha256=NLThzU_DCynOK6hkHhVdFyezwprn9UqlnrLDe_3qhkY,9347
 supervisely/project/project_type.py,sha256=_3RqW2CnDBKFOvSIrQT1RJQaiHirs34_jiQS8CkwCpo,530
@@ -1041,9 +1041,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.247.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.247.dist-info/METADATA,sha256=O8lqgCVk_UkC_P9bHE0lXmpe25VgYyEB7CBe58bYbuA,33351
-supervisely-6.73.247.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-supervisely-6.73.247.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.247.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.247.dist-info/RECORD,,
+supervisely-6.73.248.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.248.dist-info/METADATA,sha256=0R4I5m8-EAFFV8m29WqXyaj3kbtRi5O8AbRa3OeyCpI,33351
+supervisely-6.73.248.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+supervisely-6.73.248.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.248.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.248.dist-info/RECORD,,