supervisely 6.73.287__py3-none-any.whl → 6.73.289__py3-none-any.whl

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/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/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/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/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/app/widgets/bokeh/bokeh.py

@@ -4,17 +4,13 @@ import asyncio
 import re
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from typing import Any, Callable, List, Literal, Optional
 from uuid import uuid4
 
 from fastapi.responses import HTMLResponse
 from pydantic import BaseModel
 
-from supervisely._utils import is_production
-from supervisely.api.api import Api
 from supervisely.app.widgets import Widget
-from supervisely.io.env import task_id
-from supervisely.sly_logger import logger
 
 
 class DebouncedEventHandler:
@@ -37,7 +33,6 @@ class DebouncedEventHandler:
 
 class SelectedIds(BaseModel):
     selected_ids: List[int]
-    plot_id: Optional[Union[str, int]] = None
 
 
 class Bokeh(Widget):
@@ -77,14 +72,25 @@ class Bokeh(Widget):
 
         from supervisely.app.widgets import Bokeh, IFrame
 
-        plot = Bokeh.Circle(
-            x_coordinates=[1, 2, 3, 4, 5],
-            y_coordinates=[1, 2, 3, 4, 5],
-            radii=10,
-            colors="red",
-            legend_label="Circle plot",
+        data = {
+            "x": [1, 2, 3, 4, 5],
+            "y": [1, 2, 3, 4, 5],
+            "radius": [10, 20, 30, 40, 50],
+            "colors": ["red", "green", "blue", "yellow", "purple"],
+            "ids": [1, 2, 3, 4, 5],
+            "names": ["kiwi", "kiwi", "lemon", "lemon", "lemon"],
+        }
+
+        plot_lemon = Bokeh.Circle(name="lemon")
+        plot_kiwi = Bokeh.Circle(name="kiwi")
+        bokeh = Bokeh(
+            x_axis_visible=True,
+            y_axis_visible=True,
+            grid_visible=True,
+            show_legend=True,
         )
-        bokeh = Bokeh(plots=[plot], width=1000, height=600)
+        bokeh.add_data(**data)
+        bokeh.add_plots([plot_lemon, plot_kiwi])
 
         # To allow the widget to be interacted with, you need to add it to the IFrame widget.
         iframe = IFrame()
@@ -96,126 +102,72 @@ class Bokeh(Widget):
         HTML_ROUTE = "bokeh.html"
 
     class Plot(ABC):
-        @abstractmethod
-        def add(self, plot) -> None:
-            pass
+        def __init__(self, name: Optional[str] = None, **kwargs):
+
+            self._name = name or str(uuid4())
+            self.kwargs = kwargs
 
         @abstractmethod
-        def register(self, route_path: str) -> None:
+        def add(self, plot, source) -> None:
             pass
 
+        @property
+        def name(self) -> str:
+            return self._name
+
     class Circle(Plot):
-        def __init__(
-            self,
-            x_coordinates: List[Union[int, float]],
-            y_coordinates: List[Union[int, float]],
-            radii: Optional[Union[Union[int, float], List[Union[int, float]]]] = None,
-            colors: Optional[Union[str, List[str]]] = None,
-            data: Optional[List[Any]] = None,
-            dynamic_selection: bool = False,
-            fill_alpha: float = 0.5,
-            line_color: Optional[str] = None,
-            legend_label: Optional[str] = None,
-            plot_id: Optional[Union[str, int]] = None,
-        ):
-            if not colors:
-                colors = Bokeh._generate_colors(x_coordinates, y_coordinates)
-            elif isinstance(colors, str):
-                colors = [colors] * len(x_coordinates)
-
-            if not radii:
-                radii = Bokeh._generate_radii(x_coordinates, y_coordinates)
-            elif isinstance(radii, (int, float)):
-                radii = [radii] * len(x_coordinates)
-
-            if not len(x_coordinates) == len(y_coordinates) == len(radii) == len(colors):
-                raise ValueError(
-                    "x_coordinates, y_coordinates, radii, and colors must have the same length"
-                )
-
-            if data is not None and len(data) != len(x_coordinates):
-                raise ValueError("data must have the same length as x_coordinates")
-
-            if data is None:
-                data = list(range(len(x_coordinates)))
-
-            self._x_coordinates = x_coordinates
-            self._y_coordinates = y_coordinates
-            self._radii = radii
-            self._colors = colors
-            self._data = data
-            self._source = None
-            self._dynamic_selection = dynamic_selection
-            self._fill_alpha = fill_alpha
-            self._line_color = line_color
-            self._plot_id = plot_id or uuid4().hex
-            self._legend_label = legend_label or str(self._plot_id)
-
-        def add(self, plot) -> None:
+        def add(self, plot, source) -> None:
             from bokeh.models import (  # pylint: disable=import-error
-                ColumnDataSource,
-                LassoSelectTool,
-            )
-
-            data = dict(
-                x=self._x_coordinates,
-                y=self._y_coordinates,
-                radius=self._radii,
-                colors=self._colors,
-                ids=self._data,
+                CDSView,
+                GroupFilter,
             )
-            self._source = ColumnDataSource(data=data)
 
-            renderer = plot.circle(
+            filters = [GroupFilter(column_name="names", group=self.name, name=self.name)]
+            view = CDSView(source=source, filters=filters)
+            return plot.circle(
                 "x",
                 "y",
                 radius="radius",
                 fill_color="colors",
-                fill_alpha=self._fill_alpha,
-                line_color=self._line_color,
-                source=self._source,
-                legend_label=self._legend_label,
+                fill_alpha=0.5,
+                source=source,
+                line_color=None,
+                view=view,
             )
-            if not self._dynamic_selection:
-                for tool in plot.tools:
-                    if isinstance(tool, (LassoSelectTool)):
-                        tool.continuous = False
-
-            return renderer
-
-        def register(self, route_path: str) -> None:
-            from bokeh.models import CustomJS  # pylint: disable=import-error
-
-            if not hasattr(self, "_source"):
-                raise ValueError("Plot must be added to a Bokeh plot before registering")
-
-            if is_production():
-                api = Api()
-                task_info = api.task.get_info_by_id(task_id())
-                if task_info is not None:
-                    route_path = f"/net/{task_info['meta']['sessionToken']}{route_path}"
-            callback = CustomJS(
-                args=dict(source=self._source),
-                code="""
-                    var indices = source.selected.indices;
-                    var selected_ids = [];
-                    for (var i = 0; i < indices.length; i++) {{
-                        selected_ids.push(source.data['ids'][indices[i]]);
-                    }}
-                    var xhr = new XMLHttpRequest();
-                    xhr.open("POST", "{route_path}", true);
-                    xhr.setRequestHeader("Content-Type", "application/json");
-                    xhr.send(JSON.stringify({{selected_ids: selected_ids, plot_id: '{plot_id}'}}));
-                """.format(
-                    route_path=route_path,
-                    plot_id=self._plot_id,
-                ),
+
+    class Scatter(Plot):
+        def add(self, plot, source) -> None:
+            from bokeh.models import (  # pylint: disable=import-error
+                CDSView,
+                GroupFilter,
+            )
+
+            filters = [GroupFilter(column_name="names", group=self.name, name=self.name)]
+            view = CDSView(source=source, filters=filters)
+            return plot.scatter(
+                "x",
+                "y",
+                size="radius",
+                color="colors",
+                fill_alpha=0.5,
+                source=source,
+                view=view,
+            )
+
+    class Line(Plot):
+        def add(self, plot, source) -> None:
+            from bokeh.models import (  # pylint: disable=import-error
+                CDSView,
+                GroupFilter,
             )
-            self._source.selected.js_on_change("indices", callback)
+
+            filters = [GroupFilter(column_name="names", group=self.name, name=self.name)]
+            view = CDSView(source=source, filters=filters)
+            return plot.line("x", "y", source=source, view=view, line_width=2)
 
     def __init__(
         self,
-        plots: List[Plot],
+        plots: List[Plot] = None,
         width: int = 1000,
         height: int = 600,
         tools: List[str] = [
@@ -223,7 +175,7 @@ class Bokeh(Widget):
             "wheel_zoom",
             "box_zoom",
             "reset",
-            "save",
+            # "save",
             "poly_select",
             "tap",
             "lasso_select",
@@ -244,8 +196,11 @@ class Bokeh(Widget):
         if bokeh.__version__ != "3.1.1":
             raise RuntimeError(f"Bokeh version {bokeh.__version__} is not supported. Use 3.1.1")
 
+        self._source_data = {"x": [], "y": [], "radius": [], "colors": [], "ids": [], "names": []}
+        self._source = None
         self.widget_id = widget_id
-        self._plots = plots
+        self._plots = plots or []
+        self._view = None
 
         self._width = width
         self._height = height
@@ -259,56 +214,14 @@ class Bokeh(Widget):
         self._legend_click_policy = legend_click_policy
 
         super().__init__(widget_id=widget_id, file_path=__file__)
-        self._load_chart()
+
+        self._update()
 
         server = self._sly_app.get_server()
 
         @server.get(self.html_route)
         def _html_response() -> None:
-            return HTMLResponse(content=self.get_html())
-
-        # TODO: support for offline mode
-        # JinjaWidgets().context.pop(self.widget_id, None)  # remove the widget from index.html
-
-    def _load_chart(self, **kwargs):
-        from bokeh.models import Legend  # pylint: disable=import-error
-        from bokeh.plotting import figure  # pylint: disable=import-error
-
-        self._width = kwargs.get("width", self._width)
-        self._height = kwargs.get("height", self._height)
-        self._tools = kwargs.get("tools", self._tools)
-        self._toolbar_location = kwargs.get("toolbar_location", self._toolbar_location)
-        self._show_legend = kwargs.get("show_legend", self._show_legend)
-        self._legend_location = kwargs.get("legend_location", self._legend_location)
-        self._legend_click_policy = kwargs.get("legend_click_policy", self._legend_click_policy)
-        self._x_axis_visible = kwargs.get("x_axis_visible", self._x_axis_visible)
-        self._y_axis_visible = kwargs.get("y_axis_visible", self._y_axis_visible)
-        self._grid_visible = kwargs.get("grid_visible", self._grid_visible)
-
-        self._plot = figure(
-            width=self._width,
-            height=self._height,
-            tools=self._tools,
-            toolbar_location=self._toolbar_location,
-        )
-
-        if self._show_legend:
-            self._plot.add_layout(
-                Legend(click_policy=self._legend_click_policy),
-                self._legend_location,
-            )
-
-        self._plot.xaxis.visible = self._x_axis_visible
-        self._plot.yaxis.visible = self._y_axis_visible
-        self._plot.grid.visible = self._grid_visible
-
-        self._renderers = []
-        self._process_plots(self._plots)
-        self._update_html()
-
-    @property
-    def route_path(self) -> str:
-        return self.get_route_path(Bokeh.Routes.VALUE_CHANGED)
+            return HTMLResponse(content=self._get_html())
 
     @property
     def html_route(self) -> str:
@@ -318,48 +231,75 @@ class Bokeh(Widget):
     def html_route_with_timestamp(self) -> str:
         return f".{self.html_route}?t={datetime.now().timestamp()}"
 
-    def add_plots(self, plots: List[Plot]) -> None:
-        self._plots.extend(plots)
-        self._process_plots(plots)
-        self._update_html()
+    def get_json_data(self):
+        return {}
 
-    def clear(self) -> None:
-        self._plots = []
-        self._renderers = []
-        self._plot.renderers = []
-        self._update_html()
+    def get_json_state(self):
+        return {}
 
-    def remove_plot(self, idx: int) -> None:
-        renderer = self._renderers.pop(idx)
-        self._plot.renderers.remove(renderer)
-        self._update_html()
+    def _add_callbacks(self):
+        from bokeh.models import CustomJS  # pylint: disable=import-error
+
+        route_path = self.get_route_path(Bokeh.Routes.VALUE_CHANGED)
+        callback = CustomJS(
+            args=dict(source=self._source),
+            code=f"""
+                var indices = source.selected.indices;
+                var selected_ids = [];
+                for (var i = 0; i < indices.length; i++) {{
+                    selected_ids.push(source.data['ids'][indices[i]]);
+                }}
+                var xhr = new XMLHttpRequest();
+                xhr.open("POST", "{route_path}", true);
+                xhr.setRequestHeader("Content-Type", "application/json");
+                xhr.send(JSON.stringify({{selected_ids: selected_ids}}));
+            """,
+        )
+        self._source.selected.js_on_change("indices", callback)
 
-    def _process_plots(self, plots: List[Plot]) -> None:
-        for plot in plots:
-            renderer = plot.add(self._plot)
-            plot.register(self.route_path)
-            self._renderers.append(renderer)
+    def _get_html(self) -> str:
+        return f"""<div>
+            <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-3.1.1.min.js"></script>
+            {self._script}
+            {self._div}
+        </div>"""
+
+    def _create_figure(self):
+        from bokeh.models import (  # pylint: disable=import-error
+            ColumnDataSource,
+            Legend,
+        )
+        from bokeh.plotting import figure  # pylint: disable=import-error
+
+        self._plot = figure(width=self._width, height=self._height, tools=self._tools)
+
+        self._plot.xaxis.visible = self._x_axis_visible
+        self._plot.yaxis.visible = self._y_axis_visible
+        self._plot.grid.visible = self._grid_visible
 
-    def _update_html(self) -> None:
+        self._source = ColumnDataSource(data=self._source_data)
+        self._add_callbacks()
+        legend_items = []
+        for plot in self._plots:
+            r = plot.add(self._plot, self._source)
+            legend_items.append((plot.name, [r]))
+
+        if self._show_legend:
+            self._plot.add_layout(
+                Legend(items=legend_items, click_policy=self._legend_click_policy),
+                self._legend_location,
+            )
+
+    def _update_html(self):
         from bokeh.embed import components  # pylint: disable=import-error
 
-        script, self._div = components(self._plot, wrap_script=False)
+        script, self._div = components(self._plot)
         self._div_id = self._get_div_id(self._div)
         self._script = self._update_script(script)
 
-    @staticmethod
-    def _generate_colors(x_coordinates: List[int], y_coordinates: List[int]) -> List[str]:
-        colors = [
-            "#%02x%02x%02x" % (int(r), int(g), 150)
-            for r, g in zip(
-                [50 + 2 * xi for xi in x_coordinates], [30 + 2 * yi for yi in y_coordinates]
-            )
-        ]
-        return colors
-
-    @staticmethod
-    def _generate_radii(x_coordinates: List[int], y_coordinates: List[int]) -> List[int]:
-        return [1] * len(x_coordinates)
+    def _update(self):
+        self._create_figure()
+        self._update_html()
 
     def _get_div_id(self, div: str) -> str:
         match = re.search(r'id="([^"]+)"', div)
@@ -368,69 +308,98 @@ class Bokeh(Widget):
         raise ValueError(f"No div id found in {div}")
 
     def _update_script(self, script: str) -> str:
-        # TODO: Reimplement using regex.
         insert_after = "const fn = function() {"
         updated_script = ""
         for line in script.split("\n"):
             if line.strip().startswith(insert_after):
-                line = line + f"\n    const el = document.querySelector('#{self._div_id}');"
-                line += "\n    if (el === null) {"
-                line += "\n      setTimeout(fn, 500);"
-                line += "\n      return;"
-                line += "\n    }"
+                line += f"""
+                    const el = document.querySelector('#{self._div_id}');
+                    if (el === null) {{
+                        setTimeout(fn, 200);
+                        return;
+                    }}
+                """
             updated_script += line + "\n"
         return updated_script
 
-    def get_json_data(self):
-        return {}
-
-    def get_json_state(self):
-        return {}
-
     def value_changed(self, func: Callable) -> Callable:
+        """Registers a callback function that will be called when the chart is clicked."""
+
         server = self._sly_app.get_server()
+        route_path = self.get_route_path(Bokeh.Routes.VALUE_CHANGED)
         self._changes_handled = True
-        debounced_handler = DebouncedEventHandler(debounce_time=0.2)  # TODO: check if it's enough
+        debounced_handler = DebouncedEventHandler(debounce_time=0.2)
 
-        @server.post(self.route_path)
+        @server.post(route_path)
         async def _click(data: SelectedIds) -> None:
-            debounced_handler.handle_event(data, func)
+            debounced_handler.handle_event(data.selected_ids, func)
 
         return _click
 
-    def get_html(self) -> str:
-        return f"""<div>
-            <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-3.1.1.min.js"></script>
-            <script type="text/javascript"> {self._script} </script>
-            {self._div}
-        </div>"""
+    def clear(self) -> None:
+        """Clears all data in the ColumnDataSource and removes plots."""
 
-    def update_radii(self, new_radii: Union[List[Union[list, int, float]], int, float]) -> None:
-        if isinstance(new_radii, (int, float)):
-            new_radii = [new_radii] * len(self._plots)
-        elif len(new_radii) != len(self._plots):
-            logger.warning(
-                f"{len(new_radii)} != {len(self._plots)}: new_radii will be broadcasted to all plots"
-            )
-            new_radii = [new_radii[0]] * len(self._plots)
-        for idx, radii in enumerate(new_radii):
-            self.update_radii_by_plot_idx(idx, radii)
-
-    def update_radii_by_plot_idx(self, plot_idx: int, new_radii: List[Union[int, float]]) -> None:
-        coords_length = len(self._plots[plot_idx]._x_coordinates)
-        if isinstance(new_radii, (int, float)):
-            new_radii = [new_radii] * coords_length
-        elif len(new_radii) != coords_length:
-            logger.warning(
-                f"{len(new_radii)} != {coords_length}: new_radii will be broadcasted to all plots"
-            )
-            new_radii = [new_radii[0]] * coords_length
+        self._source_data = {key: [] for key in self._source_data.keys()}
+        self._plots = []
+        self._update()
+
+    def refresh(self) -> None:
+        """Refreshes the chart by reloading the existing data and updating the HTML."""
+
+        self._update()
+
+    def update_chart_size(self, width: Optional[int] = None, height: Optional[int] = None):
+        """Updates the size of the chart."""
+
+        if width:
+            self._width = width
+        if height:
+            self._height = height
+        self._update()
+
+    def add_data(
+        self,
+        x: List[float],
+        y: List[float],
+        radius: List[float],
+        colors: List[str],
+        ids: List[Any],
+        names: List[str],
+        append: bool = True,
+    ):
+        """Adds data to the chart."""
+
+        if append:
+            self._source.data["x"] += x
+            self._source.data["y"] += y
+            self._source.data["radius"] += radius
+            self._source.data["colors"] += colors
+            self._source.data["ids"] += ids
+            self._source.data["names"] += names
+        else:
+            self._source.data = {
+                "x": x,
+                "y": y,
+                "radius": radius,
+                "colors": colors,
+                "ids": ids,
+                "names": names,
+            }
+
+    def add_plot(self, plot: Plot):
+        """Adds a plot to the chart."""
+
+        self._plots.append(plot)
+        self._update()
+
+    def add_plots(self, plots: List[Plot]):
+        """Adds multiple plots to the chart."""
+
+        self._plots.extend(plots)
+        self._update()
 
-        self._plots[plot_idx]._radii = new_radii
-        self._plots[plot_idx]._source.data["radius"] = new_radii
-        self._load_chart()
+    def update_point_size(self, size: float):
+        """Updates the size of the points in the chart."""
 
-    def update_chart_size(self, width: Optional[int] = None, height: Optional[int] = None) -> None:
-        self._width = width or self._width
-        self._height = height or self._height
-        self._load_chart()
+        self._source_data["radius"] = [size] * len(self._source_data["x"])
+        self._update()

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/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/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.dist-info → supervisely-6.73.289.dist-info}/METADATA

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

{supervisely-6.73.287.dist-info → supervisely-6.73.289.dist-info}/RECORD

@@ -5,7 +5,7 @@ supervisely/function_wrapper.py,sha256=R5YajTQ0GnRp2vtjwfC9hINkzQc0JiyGsu8TER373
 supervisely/sly_logger.py,sha256=LG1wTyyctyEKuCuKM2IKf_SMPH7BzkTsFdO-0tnorzg,6225
 supervisely/tiny_timer.py,sha256=hkpe_7FE6bsKL79blSs7WBaktuPavEVu67IpEPrfmjE,183
 supervisely/annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-supervisely/annotation/annotation.py,sha256=Kdn3HRpx7ie6vkDaQFXrg597nOidZ6FMN-oXpDk4nyI,114289
+supervisely/annotation/annotation.py,sha256=5AG1AhebkmiYy2r7nKbz6TjdmCF4tuf9FtqUjLLs7aU,114659
 supervisely/annotation/annotation_transforms.py,sha256=TlVy_gUbM-XH6GbLpZPrAi6pMIGTr7Ow02iSKOSTa-I,9582
 supervisely/annotation/json_geometries_map.py,sha256=nL6AmMhFy02fw9ryBm75plKyOkDh61QdOToSuLAcz_Q,1659
 supervisely/annotation/label.py,sha256=NpHZ5o2H6dI4KiII22o2HpiLXG1yekh-bEy8WvI2Ljg,37498
@@ -21,14 +21,14 @@ 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=kB9l0NhQEkunGDC9fWjNzf5DdhqRF1tv-RRnIbkV2k0,64941
-supervisely/api/api.py,sha256=0dgPx_eizoCEFzfT8YH9uh1kq-OJwjrV5fBGD7uZ7E4,65840
+supervisely/api/annotation_api.py,sha256=fVQJOg5SLcD_mRUmPaVsJIOVTGFhsabRXqve0LyUgrc,64743
+supervisely/api/api.py,sha256=YBE6yi682H5dy3BBQtESmfC9hKZcbHyYRPNGLRldgSU,66014
 supervisely/api/app_api.py,sha256=RsbVej8WxWVn9cNo5s3Fqd1symsCdsfOaKVBKEUapRY,71927
 supervisely/api/dataset_api.py,sha256=GH7prDRJKyJlTv_7_Y-RkTwJN7ED4EkXNqqmi3iIdI4,41352
 supervisely/api/file_api.py,sha256=v2FsD3oljwNPqcDgEJRe8Bu5k0PYKzVhqmRb5QFaHAQ,83422
 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=qZwTjeCo6bkEuXDuB8RhhP0g6PzlRuCXJkUfN9rsUZ4,190985
+supervisely/api/image_api.py,sha256=bSal6vB2c7Ct2qDarXTaTmXy7x0X1VlV8oTuT6YpY2o,191061
 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
@@ -49,7 +49,7 @@ supervisely/api/video_annotation_tool_api.py,sha256=3A9-U8WJzrTShP_n9T8U01M9FzGY
 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=deYCZNG7JeDhxlYew51FyGvqY3dc7fkERtwmBPJmHcw,24503
+supervisely/api/entity_annotation/figure_api.py,sha256=jNObHAjy2JdXvKLP5IeBWISDjrZn_Budxp9J3Odyhxo,24531
 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
@@ -129,7 +129,7 @@ supervisely/app/widgets/binded_input_number/__init__.py,sha256=47DEQpj8HBSa-_TIm
 supervisely/app/widgets/binded_input_number/binded_input_number.py,sha256=RXTAGaMXtGOl4pprVLyQosr61t2rI_U_U8VNHhSyBhA,6251
 supervisely/app/widgets/binded_input_number/template.html,sha256=uCEZ54BNC2itr39wxxThXw62WlJ9659cuz8osCm0WZE,162
 supervisely/app/widgets/bokeh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-supervisely/app/widgets/bokeh/bokeh.py,sha256=zob2F-cJ6JX_Dk2FANfN94uHDyxvgoxuBpeL0OebVyg,16128
+supervisely/app/widgets/bokeh/bokeh.py,sha256=H53AqKc3sGJU3aoYeIdFfJoeIquyxbIHCDV8CRBjrUs,13262
 supervisely/app/widgets/bokeh/template.html,sha256=ntsh7xx4q9OHG62sa_r3INDxsXgvdPFIWTtYaWn_0t8,12
 supervisely/app/widgets/button/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/app/widgets/button/button.py,sha256=zDQinhOOjNNxdP2GIFrwTmVfGAeJJoKV6CT6C8KzQNI,10405
@@ -677,7 +677,7 @@ supervisely/geometry/cuboid.py,sha256=oxsRoTKuwTNxH4Vp6khyvw1TCrBagSWNV5HmQKJZHt
 supervisely/geometry/cuboid_2d.py,sha256=-oXeKiUS2gguQ4GyIZYp1cNPPhOLsGOFZl7uI71BfZM,13438
 supervisely/geometry/cuboid_3d.py,sha256=x472ZPHTZDIY5Dj8tKbLQG3BCukFPgSvPJlxfHdKi1w,4168
 supervisely/geometry/geometry.py,sha256=dbXnct8hrr7Wour6yCrtAef22KSJ2uYRm1F5GE10_MM,15287
-supervisely/geometry/graph.py,sha256=1_tX7FGmYkXuAx3P_w4zA4p8mRYnCN4iZ--2pMyxseI,24121
+supervisely/geometry/graph.py,sha256=RDdZtN_P7TKAg4s_QXluCGzdmhD-IeonvK4Pix924kk,24474
 supervisely/geometry/helpers.py,sha256=2gdYMFWTAr836gVXcp-lkDQs9tdaV0ou33kj3mzJBQA,5132
 supervisely/geometry/image_rotator.py,sha256=wrU8cXEUfuNcmPms2myUV4BpZqz_2oDArsEUFeiTpxs,6888
 supervisely/geometry/main_tests.py,sha256=K3Olsz9igHDW2IfIA5JOpjoE8bZ3ex2PXvVR2ZCDrHU,27199
@@ -689,7 +689,7 @@ supervisely/geometry/point_location.py,sha256=vLu5pWdtAi-WVQUKgFO7skigTaR-mtWR0t
 supervisely/geometry/pointcloud.py,sha256=cc4P_UNLGx5dWah3caRJytW7_mAi8UnYsJOa20mUy8s,1472
 supervisely/geometry/polygon.py,sha256=cAgCR8ccdGtieJTnmDnupPALMEwerHIqMWx7k3OCzVQ,11594
 supervisely/geometry/polyline.py,sha256=LjjD-YGVDw1TQ84_IOHqnq43JFuSnsGdGMx404olYDs,8258
-supervisely/geometry/rectangle.py,sha256=f-Y6AnVYbMXXaAOLREyjqVJeb-l_tevQQHy9kiMKHhI,33749
+supervisely/geometry/rectangle.py,sha256=QaBcSPeH87rcwsSft1TavEdCe4NpvfHZztZMEmzIxGk,33869
 supervisely/geometry/sliding_windows.py,sha256=VWtE3DS9AaIlS0ch0PY6wwtWU89J82icDRZ-F0LFrjM,1700
 supervisely/geometry/sliding_windows_fuzzy.py,sha256=InvJlH6MEW55DM1IdoMHP2MLFLieTDZfHrZZEINLQOc,3626
 supervisely/geometry/validation.py,sha256=G5vjtiXTCaTQvWegPIBiNw8pN_GiY86OUSRSsccdyLU,2139
@@ -1009,7 +1009,7 @@ supervisely/project/data_version.py,sha256=nknaWJSUCwoDyNG9_d1KA-GjzidhV9zd9Cn8c
 supervisely/project/download.py,sha256=zb8sb4XZ6Qi3CP7fmtLRUAYzaxs_W0WnOfe2x3ZVRMs,24639
 supervisely/project/pointcloud_episode_project.py,sha256=yiWdNBQiI6f1O9sr1pg8JHW6O-w3XUB1rikJNn3Oung,41866
 supervisely/project/pointcloud_project.py,sha256=Kx1Vaes-krwG3BiRRtHRLQxb9G5m5bTHPN9IzRqmNWo,49399
-supervisely/project/project.py,sha256=tvNPGyIZVs4p3iMz2eDU1tmtsPZWZOhQ9vBJCqCMxbs,202003
+supervisely/project/project.py,sha256=34fAbYV4VdfVSqMs0a5ggAIwELd8nPb-uGoaC1F7h4I,202299
 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
@@ -1071,9 +1071,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.287.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.287.dist-info/METADATA,sha256=9oifX7yDdPoCm5GaVVjDyURQrPfVIjGIT27n3C10lf8,33573
-supervisely-6.73.287.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-supervisely-6.73.287.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.287.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.287.dist-info/RECORD,,
+supervisely-6.73.289.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.289.dist-info/METADATA,sha256=RMgZIP_bwLgos0vF9tP2PFNzmKVI5h1VFkdK_bX7WKE,33573
+supervisely-6.73.289.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+supervisely-6.73.289.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.289.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.289.dist-info/RECORD,,