supervisely 6.73.287__tar.gz → 6.73.288__tar.gz

{supervisely-6.73.287/supervisely.egg-info → supervisely-6.73.288}/PKG-INFO

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

{supervisely-6.73.287 → supervisely-6.73.288}/supervisely/annotation/annotation.py

@@ -543,7 +543,7 @@ class Annotation:
             image_id=take_with_default(image_id, self.image_id),
         )
 
-    def _add_labels_impl(self, dest, labels):
+    def _add_labels_impl(self, dest: List, labels: List[Label]):
         """
         The function _add_labels_impl extend list of the labels of the current Annotation object
         :param dest: destination list of the Label class objects
@@ -554,7 +554,15 @@ class Annotation:
             if self.img_size.count(None) == 0:
                 # image has resolution in DB
                 canvas_rect = Rectangle.from_size(self.img_size)
-                dest.extend(label.crop(canvas_rect))
+                try:
+                    dest.extend(label.crop(canvas_rect))
+                except Exception:
+                    logger.error(
+                        f"Cannot crop label of '{label.obj_class.name}' class "
+                        "when extend list of the labels of the current Annotation object",
+                        exc_info=True,
+                    )
+                    raise
             else:
                 # image was uploaded by link and does not have resolution in DB
                 # add label without normalization and validation

{supervisely-6.73.287 → supervisely-6.73.288}/supervisely/api/annotation_api.py

@@ -1403,37 +1403,33 @@ class AnnotationApi(ModuleApi):
                 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]
+        # 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 = 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,
             )
-            # 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 = 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]
-                    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
+            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,

{supervisely-6.73.287 → supervisely-6.73.288}/supervisely/api/api.py

@@ -66,10 +66,10 @@ import supervisely.io.env as sly_env
 from supervisely._utils import camel_to_snake, is_community, is_development
 from supervisely.api.module_api import ApiField
 from supervisely.io.network_exceptions import (
+    RetryableRequestException,
     process_requests_exception,
     process_requests_exception_async,
     process_unhandled_request,
-    RetryableRequestException,
 )
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.sly_logger import logger
@@ -380,6 +380,7 @@ class Api:
         self.async_httpx_client: httpx.AsyncClient = None
         self.httpx_client: httpx.Client = None
         self._semaphore = None
+        self._instance_version = None
 
     @classmethod
     def normalize_server_address(cls, server_address: str) -> str:
@@ -515,11 +516,14 @@ class Api:
                 # '6.9.13'
         """
         try:
-            version = self.post("instance.version", {}).json().get(ApiField.VERSION)
+            if self._instance_version is None:
+                self._instance_version = (
+                    self.post("instance.version", {}).json().get(ApiField.VERSION)
+                )
         except Exception as e:
             logger.warning(f"Failed to get instance version from server: {e}")
-            version = "unknown"
-        return version
+            self._instance_version = "unknown"
+        return self._instance_version
 
     def is_version_supported(self, version: Optional[str] = None) -> Union[bool, None]:
         """Check if the given version is lower or equal to the current Supervisely instance version.

{supervisely-6.73.287 → supervisely-6.73.288}/supervisely/api/entity_annotation/figure_api.py

@@ -642,13 +642,13 @@ class FigureApi(RemoveableBulkModuleApi):
                 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
+                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,

{supervisely-6.73.287 → supervisely-6.73.288}/supervisely/api/image_api.py

@@ -4456,26 +4456,26 @@ class ImageApi(RemoveableBulkModuleApi):
                 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))
+            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
+                yield img_id, part.content
 
     async def get_list_generator_async(
         self,

{supervisely-6.73.287 → supervisely-6.73.288}/supervisely/geometry/graph.py

@@ -9,6 +9,7 @@ from typing import Dict, List, Optional, Tuple, Union
 import cv2
 import numpy as np
 
+from supervisely import logger
 from supervisely.geometry.constants import (
     CLASS_ID,
     CREATED_AT,
@@ -215,6 +216,8 @@ class GraphNodes(Geometry):
             updated_at=updated_at,
             created_at=created_at,
         )
+        if len(nodes) == 0:
+            raise ValueError("Empty list of nodes is not allowed for GraphNodes")
         self._nodes = nodes
         if isinstance(nodes, (list, tuple)):
             self._nodes = {}
@@ -593,6 +596,10 @@ class GraphNodes(Geometry):
 
             rectangle = figure.to_bbox()
         """
+        if self._nodes is None or len(self._nodes) == 0:
+            logger.warning(
+                f"Cannot create a bounding box from {self.name()} with empty nodes. Geometry ID: {self.sly_id} "
+            )
         return Rectangle.from_geometries_list(
             [Point.from_point_location(node.location) for node in self._nodes.values()]
         )

{supervisely-6.73.287 → supervisely-6.73.288}/supervisely/geometry/rectangle.py

@@ -476,7 +476,7 @@ class Rectangle(Geometry):
         return cls(0, 0, size[0] - 1, size[1] - 1)
 
     @classmethod
-    def from_geometries_list(cls, geometries: List[sly.geometry.geometry]) -> Rectangle:
+    def from_geometries_list(cls, geometries: List[Geometry]) -> Rectangle:
         """
         Create Rectangle from given geometry objects.
 
@@ -494,6 +494,8 @@ class Rectangle(Geometry):
             geom_objs = [sly.Point(100, 200), sly.Polyline([sly.PointLocation(730, 2104), sly.PointLocation(2479, 402)])]
             figure_from_geom_objs = sly.Rectangle.from_geometries_list(geom_objs)
         """
+        if geometries is None or len(geometries) == 0:
+            raise ValueError("No geometries provided to create a Rectangle.")
         bboxes = [g.to_bbox() for g in geometries]
         top = min(bbox.top for bbox in bboxes)
         left = min(bbox.left for bbox in bboxes)

{supervisely-6.73.287 → supervisely-6.73.288}/supervisely/project/project.py

@@ -4780,26 +4780,6 @@ async def _download_project_async(
     if semaphore is None:
         semaphore = api.get_default_semaphore()
 
-    # number of workers
-    num_workers = min(kwargs.get("num_workers", semaphore._value), 10)
-
-    async def worker(queue: asyncio.Queue, stop_event: asyncio.Event):
-        while not stop_event.is_set():
-            task = await queue.get()
-            if task is None:
-                break
-            try:
-                await task
-            except Exception as e:
-                logger.error(f"Error in _download_project_async worker: {e}")
-                stop_event.set()
-            finally:
-                queue.task_done()
-
-    queue = asyncio.Queue()
-    stop_event = asyncio.Event()
-    workers = [asyncio.create_task(worker(queue, stop_event)) 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))
@@ -4883,11 +4863,25 @@ async def _download_project_async(
                             ds_progress(1)
                 return to_download
 
+            async def run_tasks_with_delay(tasks, delay=0.1):
+                created_tasks = []
+                for task in tasks:
+                    created_task = asyncio.create_task(task)
+                    created_tasks.append(created_task)
+                    await asyncio.sleep(delay)
+                logger.debug(
+                    f"{len(created_tasks)} tasks have been created for dataset ID: {dataset.id}, Name: {dataset.name}"
+                )
+                return created_tasks
+
+            tasks = []
             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,
@@ -4901,7 +4895,7 @@ async def _download_project_async(
                     only_image_tags=only_image_tags,
                     progress_cb=ds_progress,
                 )
-                await queue.put(task)
+                tasks.append(task)
             for image in large_images:
                 task = _download_project_item_async(
                     api=api,
@@ -4915,9 +4909,10 @@ async def _download_project_async(
                     only_image_tags=only_image_tags,
                     progress_cb=ds_progress,
                 )
-                await queue.put(task)
+                tasks.append(task)
 
-        await queue.join()
+            created_tasks = await run_tasks_with_delay(tasks)
+            await asyncio.gather(*created_tasks)
 
         if save_image_meta:
             meta_dir = dataset_fs.meta_dir
@@ -4934,13 +4929,6 @@ async def _download_project_async(
             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)
-
-    if stop_event.is_set():
-        raise RuntimeError("Download process was stopped due to an error in one of the workers.")
-
     try:
         create_readme(dest_dir, project_id, api)
     except Exception as e:
@@ -4964,7 +4952,7 @@ async def _download_project_item_async(
     """
     if save_images:
         logger.debug(
-            f"Downloading 1 image in single mode: {img_info.name} with _download_project_item_async"
+            f"Downloading 1 image in single mode with _download_project_item_async. ID: {img_info.id}, Name: {img_info.name}"
         )
         img_bytes = await api.image.download_bytes_single_async(
             img_info.id, semaphore=semaphore, check_hash=True
@@ -4982,7 +4970,11 @@ async def _download_project_item_async(
             force_metadata_for_links=not save_images,
         )
         ann_json = ann_info.annotation
-        tmp_ann = Annotation.from_json(ann_json, meta)
+        try:
+            tmp_ann = Annotation.from_json(ann_json, meta)
+        except Exception:
+            logger.error(f"Error while deserializing annotation for image with ID: {img_info.id}")
+            raise
         if None in tmp_ann.img_size:
             tmp_ann = tmp_ann.clone(img_size=(img_info.height, img_info.width))
             ann_json = tmp_ann.to_json()
@@ -5004,6 +4996,7 @@ async def _download_project_item_async(
     )
     if progress_cb is not None:
         progress_cb(1)
+    logger.debug(f"Single project item has been downloaded. Semaphore state: {semaphore._value}")
 
 
 async def _download_project_items_batch_async(
@@ -5056,12 +5049,18 @@ async def _download_project_items_batch_async(
             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())
+        for img_info, ann_info in zip(img_infos, ann_infos):
+            try:
+                tmp_ann = Annotation.from_json(ann_info.annotation, meta)
+                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())
+            except Exception:
+                logger.error(
+                    f"Error while deserializing annotation for image with ID: {img_info.id}"
+                )
+                raise
     else:
         ann_jsons = []
         for img_info in img_infos:
@@ -5083,5 +5082,7 @@ async def _download_project_items_batch_async(
         if progress_cb is not None:
             progress_cb(1)
 
+    logger.debug(f"Batch of project items has been downloaded. Semaphore state: {semaphore._value}")
+
 
 DatasetDict = Project.DatasetDict

{supervisely-6.73.287 → supervisely-6.73.288/supervisely.egg-info}/PKG-INFO

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