supervisely 6.73.444__py3-none-any.whl → 6.73.468__py3-none-any.whl

supervisely/app/widgets/table/table.py

@@ -1,3 +1,5 @@
+# isort: skip_file
+
 import copy
 import io
 
@@ -54,9 +56,8 @@ class PackerUnpacker:
 
     @staticmethod
     def pandas_unpacker(data: pd.DataFrame):
-        data = data.replace({np.nan: None})
-        # data = data.astype(object).replace(np.nan, "-") # TODO: replace None later
-
+        # Keep None/NaN values in source data, don't replace them
+        # They will be converted to "" only when sending to frontend
         unpacked_data = {
             "columns": data.columns.to_list(),
             "data": data.values.tolist(),
@@ -169,9 +170,35 @@ class Table(Widget):
 
         super().__init__(widget_id=widget_id, file_path=__file__)
 
+    def _prepare_data_for_frontend(self, data_dict):
+        """Convert None and NaN values to empty strings for frontend display.
+        This preserves the original None/NaN values in _parsed_data.
+        """
+        import math
+
+        display_data = copy.deepcopy(data_dict)
+
+        # Convert None/NaN in data rows
+        for row in display_data.get("data", []):
+            for i in range(len(row)):
+                value = row[i]
+                # Check for None or NaN (NaN is a float that doesn't equal itself)
+                if value is None or (isinstance(value, float) and math.isnan(value)):
+                    row[i] = ""
+
+        # Convert None/NaN in summary row if present
+        if "summaryRow" in display_data and display_data["summaryRow"] is not None:
+            summary_row = display_data["summaryRow"]
+            for i in range(len(summary_row)):
+                value = summary_row[i]
+                if value is None or (isinstance(value, float) and math.isnan(value)):
+                    summary_row[i] = ""
+
+        return display_data
+
     def get_json_data(self):
         return {
-            "table_data": self._parsed_data,
+            "table_data": self._prepare_data_for_frontend(self._parsed_data),
             "table_options": {
                 "perPage": self._per_page,
                 "pageSizes": self._page_sizes,
@@ -255,13 +282,17 @@ class Table(Widget):
 
     def read_json(self, value: dict) -> None:
         self._update_table_data(input_data=value)
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
         self.clear_selection()
 
     def read_pandas(self, value: pd.DataFrame) -> None:
         self._update_table_data(input_data=value)
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
         self.clear_selection()
 
@@ -272,7 +303,9 @@ class Table(Widget):
         index = len(table_data) if index > len(table_data) or index < 0 else index
 
         self._parsed_data["data"].insert(index, data)
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
 
     def pop_row(self, index=-1):
@@ -284,7 +317,9 @@ class Table(Widget):
 
         if len(self._parsed_data["data"]) != 0:
             popped_row = self._parsed_data["data"].pop(index)
-            DataJson()[self.widget_id]["table_data"] = self._parsed_data
+            DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+                self._parsed_data
+            )
             DataJson().send_changes()
             return popped_row
 
@@ -382,11 +417,27 @@ class Table(Widget):
         StateJson()[self.widget_id]["selected_row"] = {}
         StateJson().send_changes()
 
+    @staticmethod
+    def _values_equal(val1, val2):
+        """Compare two values, handling NaN specially."""
+        import math
+
+        # Check if both are NaN
+        is_nan1 = isinstance(val1, float) and math.isnan(val1)
+        is_nan2 = isinstance(val2, float) and math.isnan(val2)
+        if is_nan1 and is_nan2:
+            return True
+        # Check if both are None
+        if val1 is None and val2 is None:
+            return True
+        # Regular comparison
+        return val1 == val2
+
     def delete_row(self, key_column_name, key_cell_value):
         col_index = self._parsed_data["columns"].index(key_column_name)
         row_indices = []
         for idx, row in enumerate(self._parsed_data["data"]):
-            if row[col_index] == key_cell_value:
+            if self._values_equal(row[col_index], key_cell_value):
                 row_indices.append(idx)
         if len(row_indices) == 0:
             raise ValueError('Column "{key_column_name}" does not have value "{key_cell_value}"')
@@ -400,7 +451,7 @@ class Table(Widget):
         key_col_index = self._parsed_data["columns"].index(key_column_name)
         row_indices = []
         for idx, row in enumerate(self._parsed_data["data"]):
-            if row[key_col_index] == key_cell_value:
+            if self._values_equal(row[key_col_index], key_cell_value):
                 row_indices.append(idx)
         if len(row_indices) == 0:
             raise ValueError('Column "{key_column_name}" does not have value "{key_cell_value}"')
@@ -411,20 +462,24 @@ class Table(Widget):
 
         col_index = self._parsed_data["columns"].index(column_name)
         self._parsed_data["data"][row_indices[0]][col_index] = new_value
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
 
     def update_matching_cells(self, key_column_name, key_cell_value, column_name, new_value):
         key_col_index = self._parsed_data["columns"].index(key_column_name)
         row_indices = []
         for idx, row in enumerate(self._parsed_data["data"]):
-            if row[key_col_index] == key_cell_value:
+            if self._values_equal(row[key_col_index], key_cell_value):
                 row_indices.append(idx)
 
         col_index = self._parsed_data["columns"].index(column_name)
         for row_idx in row_indices:
             self._parsed_data["data"][row_idx][col_index] = new_value
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
 
     def sort(self, column_id: int = None, direction: Optional[Literal["asc", "desc"]] = None):

supervisely/app/widgets/tree_select/tree_select.py

@@ -264,6 +264,8 @@ class TreeSelect(Widget):
 
         def _get_all_items(items: List[TreeSelect.Item]) -> List[TreeSelect.Item]:
             res = []
+            if not items:
+                return res
             for item in items:
                 res.append(item)
                 res.extend(_get_all_items(item.children))

supervisely/convert/image/csv/csv_converter.py

@@ -24,6 +24,7 @@ from supervisely.io.fs import (
     get_file_name_with_ext,
     list_files_recursively,
 )
+from supervisely.io.env import team_id
 from supervisely.io.json import load_json_file
 from supervisely.project.project_settings import LabelingInterface
 
@@ -78,16 +79,16 @@ class CSVConverter(ImageConverter):
     }
 
     def __init__(
-            self,
-            input_data: str,
-            labeling_interface: Optional[Union[LabelingInterface, str]],
-            upload_as_links: bool,
-            remote_files_map: Optional[Dict[str, str]] = None,
+        self,
+        input_data: str,
+        labeling_interface: Optional[Union[LabelingInterface, str]],
+        upload_as_links: bool,
+        remote_files_map: Optional[Dict[str, str]] = None,
     ):
         super().__init__(input_data, labeling_interface, upload_as_links, remote_files_map)
 
+        self._supports_links = True
         self._csv_reader = None
-        self._team_id = None
 
     def __str__(self):
         return AvailableImageConverters.CSV
@@ -121,6 +122,12 @@ class CSVConverter(ImageConverter):
 
         full_path = valid_files[0]
 
+        if self.upload_as_links and self._supports_links:
+            for local_path, remote_path in self._remote_files_map.items():
+                if local_path.endswith(full_path):
+                    self._api.storage.download(self._team_id, remote_path, local_path)
+                    break
+
         file_ext = get_file_ext(full_path)
         if file_ext in self.conversion_functions:
             csv_full_path = os.path.splitext(full_path)[0] + ".csv"
@@ -147,7 +154,7 @@ class CSVConverter(ImageConverter):
                         team_files = False
                     break
             if item_path is None:
-                logger.warn(f"Failed to find image path in row: {row}. Skipping.")
+                logger.warning(f"Failed to find image path in row: {row}. Skipping.")
                 continue
             ann_data = row.get("tag")
             item = CSVConverter.Item(
@@ -192,7 +199,7 @@ class CSVConverter(ImageConverter):
                 ann_json = csv_helper.rename_in_json(ann_json, renamed_classes, renamed_tags)
             return Annotation.from_json(ann_json, meta)
         except Exception as e:
-            logger.warn(f"Failed to convert annotation: {repr(e)}")
+            logger.warning(f"Failed to convert annotation: {repr(e)}")
             return item.create_empty_annotation()
 
     def process_remote_image(
@@ -209,19 +216,21 @@ class CSVConverter(ImageConverter):
         image_path = image_path.strip()
         if is_team_file:
             if not api.file.exists(team_id, image_path):
-                logger.warn(f"File {image_path} not found in Team Files. Skipping...")
+                logger.warning(f"File {image_path} not found in Team Files. Skipping...")
                 return None
             team_file_image_info = api.file.list(team_id, image_path)
             image_path = team_file_image_info[0]["fullStorageUrl"]
             if not image_path:
-                logger.warn(f"Failed to get full storage URL for file '{image_path}'. Skipping...")
+                logger.warning(
+                    f"Failed to get full storage URL for file '{image_path}'. Skipping..."
+                )
                 return None
 
         extension = os.path.splitext(image_path)[1]
         if not extension:
-            logger.warn(f"FYI: Image [{image_path}] doesn't have extension.")
+            logger.warning(f"FYI: Image [{image_path}] doesn't have extension.")
         elif extension.lower() not in SUPPORTED_IMG_EXTS:
-            logger.warn(
+            logger.warning(
                 f"Image [{image_path}] has unsupported extension [{extension}]. Skipping..."
             )
             return None
@@ -234,7 +243,7 @@ class CSVConverter(ImageConverter):
                 force_metadata_for_links=force_metadata,
             )
         except Exception:
-            logger.warn(f"Failed to upload image {image_name}. Skipping...")
+            logger.warning(f"Failed to link image {image_name}. Skipping...")
             return None
         if progress_cb is not None:
             progress_cb(1)
@@ -312,7 +321,7 @@ class CSVConverter(ImageConverter):
                     success = False
                     continue
                 if item.name not in info.name:
-                    logger.warn(
+                    logger.warning(
                         f"Batched image with name '{item.name}' doesn't match uploaded image name '{info.name}'"
                     )
                     success = False
@@ -339,4 +348,4 @@ class CSVConverter(ImageConverter):
         if success:
             logger.info(f"Dataset ID:'{dataset_id}' has been successfully uploaded.")
         else:
-            logger.warn(f"Dataset ID:'{dataset_id}' has been uploaded.")
+            logger.warning(f"Dataset ID:'{dataset_id}' has been uploaded.")

supervisely/convert/video/video_converter.py

@@ -266,8 +266,8 @@ class VideoConverter(BaseConverter):
             if codec_type not in ["video", "audio"]:
                 continue
             codec_name = stream["codecName"]
-            if codec_type == "video" and codec_name != "h264":
-                logger.info(f"Video codec is not h264, transcoding is required: {codec_name}")
+            if codec_type == "video" and codec_name not in ["h264", "h265", "hevc", "av1"]:
+                logger.info(f"Video codec is not h264/h265/hevc/av1, transcoding is required: {codec_name}")
                 need_video_transc = True
             elif codec_type == "audio" and codec_name != "aac":
                 logger.info(f"Audio codec is not aac, transcoding is required: {codec_name}")

supervisely/geometry/polyline_3d.py

@@ -0,0 +1,110 @@
+from supervisely.geometry.geometry import Geometry
+from supervisely.geometry.constants import LABELER_LOGIN, UPDATED_AT, CREATED_AT, ID, CLASS_ID
+from supervisely.geometry.cuboid_3d import Vector3d
+from typing import List, Union
+
+
+class Polyline3D(Geometry):
+    """
+    Polyline3D geometry
+
+    :param points: List of 3D point coordinates which define the polyline in 3D space.
+    :type points: List[List[int, int, int]]
+    :param sly_id: Polyline ID in Supervisely server.
+    :type sly_id: int, optional
+    :param class_id: ID of :class:`ObjClass<supervisely.annotation.obj_class.ObjClass>` to which Polyline belongs.
+    :type class_id: int, optional
+    :param labeler_login: Login of the user who created Polyline.
+    :type labeler_login: str, optional
+    :param updated_at: Date and Time when Polyline was modified last. Date Format: Year:Month:Day:Hour:Minute:Seconds. Example: '2021-01-22T19:37:50.158Z'.
+    :type updated_at: str, optional
+    :param created_at: Date and Time when Polyline was created. Date Format is the same as in "updated_at" parameter.
+    :type created_at: str, optional
+
+    :Usage example:
+
+     .. code-block:: python
+
+        import supervisely as sly
+
+        points = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+        figure = sly.Polyline(points)
+    """
+
+    @staticmethod
+    def geometry_name():
+        return "polyline_3d"
+
+    def __init__(
+        self,
+        points: Union[List[float], List[Vector3d]],
+        sly_id=None,
+        class_id=None,
+        labeler_login=None,
+        updated_at=None,
+        created_at=None,
+    ):
+        if not isinstance(points[0], Vector3d):
+            points = [Vector3d(point[0], point[1], point[2]) for point in points]
+        super().__init__(
+            sly_id=sly_id,
+            class_id=class_id,
+            labeler_login=labeler_login,
+            updated_at=updated_at,
+            created_at=created_at,
+        )
+
+        self._points = points
+
+    @property
+    def points(self):
+        return self._points
+
+    def to_json(self):
+        points = [[point.x, point.y, point.z] for point in self._points]
+        res = {"points": points}
+        self._add_creation_info(res)
+        return res
+
+    @classmethod
+    def from_json(cls, data):
+        """
+        Convert a json dict to Polyline3D.
+
+        :param data: Polyline3D in json format as a dict.
+        :type data: dict
+        :return: Polyline3D object
+        :rtype: :class:`Polyline3D<Polyline3D>`
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            figure_json = {
+                "points": {
+                    [
+                        [1, 2, 3],
+                        [4, 5, 6],
+                        [7, 8, 9]
+                    ],
+                }
+            }
+            figure = sly.Polyline3D.from_json(figure_json)
+        """
+        if not data.get("points"):
+            raise ValueError("Data dict must contain 'points' field!")
+        points = data["points"]
+        labeler_login = data.get(LABELER_LOGIN, None)
+        updated_at = data.get(UPDATED_AT, None)
+        created_at = data.get(CREATED_AT, None)
+        sly_id = data.get(ID, None)
+        class_id = data.get(CLASS_ID, None)
+        return cls(
+            points,
+            sly_id=sly_id,
+            class_id=class_id,
+            labeler_login=labeler_login,
+            updated_at=updated_at,
+            created_at=created_at,
+        )

supervisely/io/env.py

@@ -1,10 +1,14 @@
 # coding: utf-8
 import json
 import os
+from contextvars import ContextVar, Token
 from typing import Callable, List, Literal, Optional, Union
 
 RAISE_IF_NOT_FOUND = True
-
+_MULTIUSER_USER_CTX: ContextVar[Optional[Union[int, str]]] = ContextVar(
+    "supervisely_multiuser_app_user_id",
+    default=None,
+)
 
 def flag_from_env(s: str) -> bool:
     """Returns True if passed string is a flag, False otherwise.
@@ -771,3 +775,74 @@ def add_uploaded_ids_to_env(dataset_id: int, ids: List[int]) -> None:
     else:
         uploaded[str(dataset_id)].extend(ids)
     os.environ["UPLOADED_IDS"] = json.dumps(uploaded)
+
+
+def is_multiuser_mode_enabled() -> bool:
+    """Returns multiuser app mode flag from environment variable using following keys:
+        - SUPERVISELY_MULTIUSER_APP_MODE
+    :return: multiuser app mode flag
+    :rtype: bool
+    """
+    return _parse_from_env(
+        name="is_multiuser_mode_enabled",
+        keys=["SUPERVISELY_MULTIUSER_APP_MODE"],
+        default=False,
+        raise_not_found=False,
+        postprocess_fn=flag_from_env,
+    )
+
+
+def enable_multiuser_app_mode() -> None:
+    """
+    Enables multiuser app mode by setting the environment variable.
+    This function can be used to activate multiuser mode in the application allowing
+    separation of user DataJson/StateJson.
+    """
+    os.environ["SUPERVISELY_MULTIUSER_APP_MODE"] = "true"
+
+
+def disable_multiuser_app_mode() -> None:
+    """Disables multiuser app mode by removing the environment variable."""
+    os.environ.pop("SUPERVISELY_MULTIUSER_APP_MODE", None)
+
+
+def set_user_for_multiuser_app(user_id: Optional[Union[int, str]]) -> Token:
+    """
+    Sets the user ID for multiuser app mode by setting the environment variable.
+    This function should be used in multiuser mode to separate user DataJson/StateJson.
+
+    :param user_id: The user ID (or session key) to set for the current request.
+    :type user_id: int | str
+    :return: A context token that can be used to reset the user ID later.
+    :rtype: Token
+    :raises RuntimeError: If multiuser app mode is not enabled.
+    """
+    if not is_multiuser_mode_enabled():
+        raise RuntimeError("Multiuser app mode is not enabled. Cannot set user ID.")
+    return _MULTIUSER_USER_CTX.set(user_id)
+
+
+def reset_user_for_multiuser_app(token: Token) -> None:
+    """
+    Resets the user ID for multiuser app mode using the provided context token.
+
+    :param token: Context token obtained from `set_user_for_multiuser_app`.
+    :type token: Token
+    """
+    if not is_multiuser_mode_enabled():
+        return
+    _MULTIUSER_USER_CTX.reset(token)
+
+
+def user_from_multiuser_app() -> Optional[Union[int, str]]:
+    """
+    Retrieves the user ID for multiuser app mode from the environment variable.
+
+    :return: The user ID if set, otherwise None.
+    :rtype: Optional[Union[int, str]]
+    """
+    if not is_multiuser_mode_enabled():
+        return None
+    user_id = _MULTIUSER_USER_CTX.get(None)
+    if user_id is not None:
+        return user_id

supervisely/nn/inference/cache.py

@@ -771,7 +771,7 @@ class InferenceImageCache:
     def _download_many(
         self,
         indexes: List[Union[int, str]],
-        name_cunstructor: Callable[[int], str],
+        name_constructor: Callable[[int], str],
         load_generator: Callable[
             [List[int]],
             Generator[Tuple[Union[int, str], np.ndarray], None, None],
@@ -785,24 +785,42 @@ class InferenceImageCache:
         all_frames = [None for _ in range(len(indexes))]
 
         def get_one_image(item):
-            pos, index = item
+            pos, hash_or_id = item
             if video_id in self._cache:
-                return pos, self.get_frame_from_cache(video_id, index)
-            return pos, self._cache.get_image(name_cunstructor(index))
+                try:
+                    frame = self.get_frame_from_cache(video_id, hash_or_id)
+                except Exception as e:
+                    logger.error(
+                        f"Error retrieving frame from cache: {repr(e)}. Frame will be re-downloaded",
+                        exc_info=True,
+                    )
+                    ids_to_load.append(hash_or_id)
+                    return pos, None
+                return pos, frame
+            try:
+                image = self._cache.get_image(name_constructor(hash_or_id))
+            except Exception as e:
+                logger.error(
+                    f"Error retrieving image from cache: {repr(e)}. Image will be re-downloaded",
+                    exc_info=True,
+                )
+                ids_to_load.append(hash_or_id)
+                return pos, None
+            return pos, image
 
         position = 0
         batch_size = 4
         for batch in batched(indexes, batch_size):
-            indexes_to_load = []
+            ids_to_load = []
             items = []
             for hash_or_id in batch:
-                name = name_cunstructor(hash_or_id)
+                name = name_constructor(hash_or_id)
                 self._wait_if_in_queue(name, logger)
-
+                pos_by_name[name] = position
                 if name not in self._cache and video_id not in self._cache:
                     self._load_queue.set(name, hash_or_id)
-                    indexes_to_load.append(hash_or_id)
-                    pos_by_name[name] = position
+                    ids_to_load.append(hash_or_id)
+
                 elif return_images is True:
                     items.append((position, hash_or_id))
                 position += 1
@@ -810,14 +828,16 @@ class InferenceImageCache:
             if len(items) > 0:
                 with ThreadPoolExecutor(min(64, len(items))) as executor:
                     for pos, image in executor.map(get_one_image, items):
+                        if image is None:
+                            continue
                         all_frames[pos] = image
                         if progress_cb is not None:
                             progress_cb()
 
             download_time = time.monotonic()
-            if len(indexes_to_load) > 0:
-                for id_or_hash, image in load_generator(indexes_to_load):
-                    name = name_cunstructor(id_or_hash)
+            if len(ids_to_load) > 0:
+                for id_or_hash, image in load_generator(ids_to_load):
+                    name = name_constructor(id_or_hash)
                     self._add_to_cache(name, image)
 
                     if return_images:
@@ -828,13 +848,13 @@ class InferenceImageCache:
             download_time = time.monotonic() - download_time
 
             # logger.debug(f"All stored files: {sorted(os.listdir(self.tmp_path))}")
-            if indexes_to_load:
-                indexes_to_load = list(indexes_to_load)
+            if ids_to_load:
+                ids_to_load = list(ids_to_load)
                 logger.debug(
-                    f"Images/Frames added to cache: {indexes_to_load} in {download_time:.2f} sec",
-                    extra={"indexes": indexes_to_load, "download_time": download_time},
+                    f"Images/Frames added to cache: {ids_to_load} in {download_time:.2f} sec",
+                    extra={"indexes": ids_to_load, "download_time": download_time},
                 )
-            found = set(batch).difference(indexes_to_load)
+            found = set(batch).difference(ids_to_load)
             if found:
                 logger.debug(f"Images/Frames found in cache: {list(found)}")