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

supervisely/api/dataset_api.py

@@ -1021,13 +1021,66 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
 
         return dataset_tree
 
-    def tree(self, project_id: int) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
+    def _yield_tree(
+        self, tree: Dict[DatasetInfo, Dict], path: List[str]
+    ) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
+        """
+        Helper method for recursive tree traversal.
+        Yields tuples of (path, dataset) for all datasets in the tree. For each node (dataset) at the current level,
+        yields its (path, dataset) before recursively traversing and yielding from its children.
+        
+        :param tree: Tree structure to yield from.
+        :type tree: Dict[DatasetInfo, Dict]
+        :param path: Current path (used for recursion).
+        :type path: List[str]
+        :return: Generator of tuples of (path, dataset).
+        :rtype: Generator[Tuple[List[str], DatasetInfo], None, None]
+        """
+        for dataset, children in tree.items():
+            yield path, dataset
+            new_path = path + [dataset.name]
+            if children:
+                yield from self._yield_tree(children, new_path)
+
+    def _find_dataset_in_tree(
+        self, tree: Dict[DatasetInfo, Dict], target_id: int, path: List[str] = None
+    ) -> Tuple[Optional[DatasetInfo], Optional[Dict], List[str]]:
+        """Find a specific dataset in the tree and return its subtree and path.
+        
+        :param tree: Tree structure to search in.
+        :type tree: Dict[DatasetInfo, Dict]
+        :param target_id: ID of the dataset to find.
+        :type target_id: int
+        :param path: Current path (used for recursion).
+        :type path: List[str], optional
+        :return: Tuple of (found_dataset, its_subtree, path_to_dataset).
+        :rtype: Tuple[Optional[DatasetInfo], Optional[Dict], List[str]]
+        """
+        if path is None:
+            path = []
+            
+        for dataset, children in tree.items():
+            if dataset.id == target_id:
+                return dataset, children, path
+            # Search in children
+            if children:
+                found_dataset, found_children, found_path = self._find_dataset_in_tree(
+                    children, target_id, path + [dataset.name]
+                )
+                if found_dataset is not None:
+                    return found_dataset, found_children, found_path
+        return None, None, []
+
+    def tree(self, project_id: int, dataset_id: Optional[int] = None) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
         """Yields tuples of (path, dataset) for all datasets in the project.
         Path of the dataset is a list of parents, e.g. ["ds1", "ds2", "ds3"].
         For root datasets, the path is an empty list.
 
         :param project_id: Project ID in which the Dataset is located.
         :type project_id: int
+        :param dataset_id: Optional Dataset ID to start the tree from. If provided, only yields
+            the subtree starting from this dataset (including the dataset itself and all its children).
+        :type dataset_id: Optional[int]
         :return: Generator of tuples of (path, dataset).
         :rtype: Generator[Tuple[List[str], DatasetInfo], None, None]
         :Usage example:
@@ -1040,11 +1093,17 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
 
             project_id = 123
 
+            # Get all datasets in the project
             for parents, dataset in api.dataset.tree(project_id):
                 parents: List[str]
                 dataset: sly.DatasetInfo
                 print(parents, dataset.name)
 
+            # Get only a specific branch starting from dataset_id = 456
+            for parents, dataset in api.dataset.tree(project_id, dataset_id=456):
+                parents: List[str]
+                dataset: sly.DatasetInfo
+                print(parents, dataset.name)
 
             # Output:
             # [] ds1
@@ -1052,17 +1111,20 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
             # ["ds1", "ds2"] ds3
         """
 
-        def yield_tree(
-            tree: Dict[DatasetInfo, Dict], path: List[str]
-        ) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
-            """Yields tuples of (path, dataset) for all datasets in the tree."""
-            for dataset, children in tree.items():
-                yield path, dataset
-                new_path = path + [dataset.name]
-                if children:
-                    yield from yield_tree(children, new_path)
-
-        yield from yield_tree(self.get_tree(project_id), [])
+        full_tree = self.get_tree(project_id)
+        
+        if dataset_id is None:
+            # Return the full tree
+            yield from self._yield_tree(full_tree, [])
+        else:
+            # Find the specific dataset and return only its subtree
+            target_dataset, subtree, dataset_path = self._find_dataset_in_tree(full_tree, dataset_id)
+            if target_dataset is not None:
+                # Yield the target dataset first, then its children
+                yield dataset_path, target_dataset
+                if subtree:
+                    new_path = dataset_path + [target_dataset.name]
+                    yield from self._yield_tree(subtree, new_path)
 
     def get_nested(self, project_id: int, dataset_id: int) -> List[DatasetInfo]:
         """Returns a list of all nested datasets in the specified dataset.

supervisely/app/fastapi/custom_static_files.py

@@ -42,7 +42,7 @@ class CustomStaticFiles(StaticFiles):
         def _get_range_header(range_header: str, file_size: int) -> typing.Tuple[int, int]:
             def _invalid_range():
                 return HTTPException(
-                    status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
+                    status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE, #TODO: change to status.HTTP_416_RANGE_NOT_SATISFIABLE if update starlette to 0.48.0+
                     detail=f"Invalid request range (Range:{range_header!r})",
                 )
 

supervisely/app/widgets/fast_table/fast_table.py

@@ -221,6 +221,11 @@ class FastTable(Widget):
         self._validate_input_data(data)
         self._source_data = self._prepare_input_data(data)
 
+        # Initialize filtered and searched data for proper initialization
+        self._filtered_data = self._filter(self._filter_value)
+        self._searched_data = self._search(self._search_str)
+        self._sorted_data = self._sort_table_data(self._searched_data)
+
         # prepare parsed_source_data, sliced_data, parsed_active_data
         (
             self._parsed_source_data,
@@ -265,9 +270,7 @@ class FastTable(Widget):
         self._sliced_data = self._slice_table_data(self._sorted_data, actual_page=self._active_page)
         self._parsed_active_data = self._unpack_pandas_table_data(self._sliced_data)
         StateJson().send_changes()
-        DataJson()[self.widget_id]["data"] = {
-            i: row for i, row in enumerate(self._parsed_active_data["data"])
-        }
+        DataJson()[self.widget_id]["data"] = list(self._parsed_active_data["data"])
         DataJson()[self.widget_id]["total"] = self._rows_total
         DataJson().send_changes()
         StateJson()["reactToChanges"] = True
@@ -297,7 +300,7 @@ class FastTable(Widget):
         :rtype: Dict[str, Any]
         """
         return {
-            "data": {i: row for i, row in enumerate(self._parsed_active_data["data"])},
+            "data": list(self._parsed_active_data["data"]),
             "columns": self._parsed_source_data["columns"],
             "projectMeta": self._project_meta,
             "columnsOptions": self._columns_options,
@@ -492,9 +495,7 @@ class FastTable(Widget):
             self._sort_column_idx = None
         self._sort_order = sort.get("order", None)
         self._page_size = init_options.pop("pageSize", 10) 
-        DataJson()[self.widget_id]["data"] = {
-            i: row for i, row in enumerate(self._parsed_active_data["data"])
-        }
+        DataJson()[self.widget_id]["data"] = list(self._parsed_active_data["data"])
         DataJson()[self.widget_id]["columns"] = self._parsed_active_data["columns"]
         DataJson()[self.widget_id]["columnsOptions"] = self._columns_options
         DataJson()[self.widget_id]["options"] = init_options
@@ -523,9 +524,7 @@ class FastTable(Widget):
         self._parsed_active_data = self._unpack_pandas_table_data(self._sliced_data)
         self._parsed_source_data = self._unpack_pandas_table_data(self._source_data)
         self._rows_total = len(self._parsed_source_data["data"])
-        DataJson()[self.widget_id]["data"] = {
-            i: row for i, row in enumerate(self._parsed_active_data["data"])
-        }
+        DataJson()[self.widget_id]["data"] = list(self._parsed_active_data["data"])
         DataJson()[self.widget_id]["columns"] = self._parsed_active_data["columns"]
         DataJson()[self.widget_id]["total"] = len(self._source_data)
         DataJson().send_changes()
@@ -584,10 +583,17 @@ class FastTable(Widget):
         :rtype: pd.DataFrame
         """
         if active_page is True:
-            temp_parsed_data = [d["items"] for d in self._parsed_active_data["data"]]
+            # Return sliced data directly from source to preserve None/NaN values
+            packed_data = self._sliced_data.copy()
+            # Reset column names to first level only
+            if isinstance(packed_data.columns, pd.MultiIndex):
+                packed_data.columns = packed_data.columns.get_level_values("first")
         else:
-            temp_parsed_data = [d["items"] for d in self._parsed_source_data["data"]]
-        packed_data = pd.DataFrame(data=temp_parsed_data, columns=self._columns_first_idx)
+            # Return source data directly to preserve None/NaN values
+            packed_data = self._source_data.copy()
+            # Reset column names to first level only
+            if isinstance(packed_data.columns, pd.MultiIndex):
+                packed_data.columns = packed_data.columns.get_level_values("first")
         return packed_data
 
     def clear_selection(self) -> None:
@@ -627,8 +633,12 @@ class FastTable(Widget):
             rows = []
             for row in selected_rows:
                 row_index = row["idx"]
-                row_data = row.get("row", row.get("items", None))
-                if row_index is None or row_data is None:
+                if row_index is None:
+                    continue
+                # Get original data from source_data to preserve None/NaN values
+                try:
+                    row_data = self._source_data.loc[row_index].values.tolist()
+                except (KeyError, IndexError):
                     continue
                 rows.append(self.ClickedRow(row_data, row_index))
             return rows
@@ -639,8 +649,12 @@ class FastTable(Widget):
         if clicked_row is None:
             return None
         row_index = clicked_row["idx"]
-        row = clicked_row["row"]
-        if row_index is None or row is None:
+        if row_index is None:
+            return None
+        # Get original data from source_data to preserve None/NaN values
+        try:
+            row = self._source_data.loc[row_index].values.tolist()
+        except (KeyError, IndexError):
             return None
         return self.ClickedRow(row, row_index)
 
@@ -650,15 +664,19 @@ class FastTable(Widget):
         :return: Selected cell
         :rtype: ClickedCell
         """
-        cell_data = StateJson()[self.widget_id]["clickedCell"]
+        cell_data = StateJson()[self.widget_id]["selectedCell"]
         if cell_data is None:
             return None
         row_index = cell_data["idx"]
-        row = cell_data["row"]
         column_index = cell_data["column"]
+        if column_index is None or row_index is None:
+            return None
         column_name = self._columns_first_idx[column_index]
-        column_value = row[column_index]
-        if column_index is None or row is None:
+        # Get original data from source_data to preserve None/NaN values
+        try:
+            row = self._source_data.loc[row_index].values.tolist()
+            column_value = row[column_index]
+        except (KeyError, IndexError):
             return None
         return self.ClickedCell(row, column_index, row_index, column_name, column_value)
 
@@ -721,9 +739,7 @@ class FastTable(Widget):
             self._parsed_active_data,
         ) = self._prepare_working_data()
         self._rows_total = len(self._parsed_source_data["data"])
-        DataJson()[self.widget_id]["data"] = {
-            i: row for i, row in enumerate(self._parsed_active_data["data"])
-        }
+        DataJson()[self.widget_id]["data"] = list(self._parsed_active_data["data"])
         DataJson()[self.widget_id]["total"] = self._rows_total
         DataJson().send_changes()
         self._maybe_update_selected_row()
@@ -741,9 +757,7 @@ class FastTable(Widget):
             self._parsed_active_data,
         ) = self._prepare_working_data()
         self._rows_total = len(self._parsed_source_data["data"])
-        DataJson()[self.widget_id]["data"] = {
-            i: row for i, row in enumerate(self._parsed_active_data["data"])
-        }
+        DataJson()[self.widget_id]["data"] = list(self._parsed_active_data["data"])
         DataJson()[self.widget_id]["total"] = self._rows_total
         DataJson().send_changes()
         self._maybe_update_selected_row()
@@ -771,9 +785,7 @@ class FastTable(Widget):
                 self._parsed_active_data,
             ) = self._prepare_working_data()
             self._rows_total = len(self._parsed_source_data["data"])
-            DataJson()[self.widget_id]["data"] = {
-                i: row for i, row in enumerate(self._parsed_active_data["data"])
-            }
+            DataJson()[self.widget_id]["data"] = list(self._parsed_active_data["data"])
             DataJson()[self.widget_id]["total"] = self._rows_total
             self._maybe_update_selected_row()
             return popped_row
@@ -886,7 +898,11 @@ class FastTable(Widget):
         self._refresh()
 
     def _default_search_function(self, data: pd.DataFrame, search_value: str) -> pd.DataFrame:
-        data = data[data.applymap(lambda x: search_value in str(x)).any(axis=1)]
+        # Use map() for pandas >= 2.1.0, fallback to applymap() for older versions
+        if hasattr(pd.DataFrame, "map"):
+            data = data[data.map(lambda x: search_value in str(x)).any(axis=1)]
+        else:
+            data = data[data.applymap(lambda x: search_value in str(x)).any(axis=1)]
         return data
 
     def _search(self, search_value: str) -> pd.DataFrame:
@@ -897,8 +913,14 @@ class FastTable(Widget):
         :return: Filtered data
         :rtype: pd.DataFrame
         """
-        filtered_data = self._filtered_data.copy()
+        # Use filtered_data if available, otherwise use source_data directly
+        if self._filtered_data is not None:
+            filtered_data = self._filtered_data.copy()
+        else:
+            filtered_data = self._source_data.copy()
+
         if search_value == "":
+            self._search_str = search_value
             return filtered_data
         if self._search_str != search_value:
             self._active_page = 1
@@ -924,7 +946,24 @@ class FastTable(Widget):
         else:
             ascending = False
         try:
-            data = data.sort_values(by=data.columns[column_idx], ascending=ascending)
+            column = data.columns[column_idx]
+            # Try to convert to numeric for proper sorting
+            numeric_column = pd.to_numeric(data[column], errors="coerce")
+
+            # Check if column contains numeric data (has at least one non-NaN numeric value)
+            if numeric_column.notna().sum() > 0:
+                # Create temporary column for sorting
+                data_copy = data.copy()
+                data_copy["_sort_key"] = numeric_column
+                # Sort by numeric values with NaN at the end
+                data_copy = data_copy.sort_values(
+                    by="_sort_key", ascending=ascending, na_position="last"
+                )
+                # Remove temporary column and return original data in sorted order
+                data = data.loc[data_copy.index]
+            else:
+                # Sort as strings with NaN values at the end
+                data = data.sort_values(by=column, ascending=ascending, na_position="last")
         except IndexError as e:
             e.args = (
                 f"Sorting by column idx = {column_idx} is not possible, your table has only {len(data.columns)} columns with idx from 0 to {len(data.columns) - 1}",
@@ -955,9 +994,7 @@ class FastTable(Widget):
         self._sorted_data = self._sort_table_data(self._searched_data)
         self._sliced_data = self._slice_table_data(self._sorted_data, actual_page=self._active_page)
         self._parsed_active_data = self._unpack_pandas_table_data(self._sliced_data)
-        DataJson()[self.widget_id]["data"] = {
-            i: row for i, row in enumerate(self._parsed_active_data["data"])
-        }
+        DataJson()[self.widget_id]["data"] = list(self._parsed_active_data["data"])
         DataJson()[self.widget_id]["total"] = self._rows_total
         self._maybe_update_selected_row()
         StateJson().send_changes()
@@ -1062,12 +1099,21 @@ class FastTable(Widget):
     def _get_pandas_unpacked_data(self, data: pd.DataFrame) -> dict:
         if not isinstance(data, pd.DataFrame):
             raise TypeError("Cannot parse input data, please use Pandas Dataframe as input data")
-        data = data.replace({np.nan: None})
-        # data = data.astype(object).replace(np.nan, "-") # TODO: replace None later
+
+        # Create a copy for frontend display to avoid modifying source data
+        display_data = data.copy()
+        # Replace NaN and None with empty string only for display
+        display_data = display_data.replace({np.nan: "", None: ""})
+
+        # Handle MultiIndex columns - extract only the first level
+        if isinstance(display_data.columns, pd.MultiIndex):
+            columns = display_data.columns.get_level_values("first").tolist()
+        else:
+            columns = display_data.columns.to_list()
 
         unpacked_data = {
-            "columns": data.columns.to_list(),
-            "data": data.values.tolist(),
+            "columns": columns,
+            "data": display_data.values.tolist(),
         }
         return unpacked_data
 
@@ -1238,9 +1284,7 @@ class FastTable(Widget):
 
         self._sliced_data = self._slice_table_data(self._sorted_data, actual_page=self._active_page)
         self._parsed_active_data = self._unpack_pandas_table_data(self._sliced_data)
-        DataJson()[self.widget_id]["data"] = {
-            i: row for i, row in enumerate(self._parsed_active_data["data"])
-        }
+        DataJson()[self.widget_id]["data"] = list(self._parsed_active_data["data"])
         DataJson()[self.widget_id]["total"] = self._rows_total
         DataJson().send_changes()
         StateJson().send_changes()
@@ -1309,6 +1353,7 @@ class FastTable(Widget):
 
     def select_row_by_value(self, column, value: Any):
         """Selects a row by value in a specific column.
+        The first column with the given name is used in case of duplicate column names.
 
         :param column: Column name to filter by
         :type column: str
@@ -1322,7 +1367,12 @@ class FastTable(Widget):
         if column not in self._columns_first_idx:
             raise ValueError(f"Column '{column}' does not exist in the table.")
 
-        idx = self._source_data[self._source_data[column] == value].index.tolist()
+        # Find the first column index with this name (in case of duplicates)
+        column_idx = self._columns_first_idx.index(column)
+        column_tuple = self._source_data.columns[column_idx]
+
+        # Use column tuple to access the specific column
+        idx = self._source_data[self._source_data[column_tuple] == value].index.tolist()
         if not idx:
             raise ValueError(f"No rows found with {column} = {value}.")
         if len(idx) > 1:
@@ -1333,6 +1383,7 @@ class FastTable(Widget):
 
     def select_rows_by_value(self, column, values: List):
         """Selects rows by value in a specific column.
+        The first column with the given name is used in case of duplicate column names.
 
         :param column: Column name to filter by
         :type column: str
@@ -1346,7 +1397,12 @@ class FastTable(Widget):
         if column not in self._columns_first_idx:
             raise ValueError(f"Column '{column}' does not exist in the table.")
 
-        idxs = self._source_data[self._source_data[column].isin(values)].index.tolist()
+        # Find the first column index with this name (in case of duplicates)
+        column_idx = self._columns_first_idx.index(column)
+        column_tuple = self._source_data.columns[column_idx]
+
+        # Use column tuple to access the specific column
+        idxs = self._source_data[self._source_data[column_tuple].isin(values)].index.tolist()
         self.select_rows(idxs)
 
     def _read_custom_columns(self, columns: List[Union[str, tuple]]) -> None:

supervisely/app/widgets/select_dataset_tree/select_dataset_tree.py

@@ -7,7 +7,6 @@ from supervisely.app.widgets.checkbox.checkbox import Checkbox
 from supervisely.app.widgets.container.container import Container
 from supervisely.app.widgets.field.field import Field
 from supervisely.app.widgets.select.select import Select
-from supervisely.app.widgets.select_project.select_project import SelectProject
 from supervisely.app.widgets.tree_select.tree_select import TreeSelect
 from supervisely.project.project_type import ProjectType
 
@@ -120,7 +119,15 @@ class SelectDatasetTree(Widget):
         if self._project_id:
             project_info = self._api.project.get_info_by_id(self._project_id)
             if allowed_project_types is not None:
-                if project_info.type not in [pt.value for pt in allowed_project_types]:
+                allowed_values = []
+                if not isinstance(allowed_project_types, list):
+                    allowed_project_types = [allowed_project_types]
+
+                for pt in allowed_project_types:
+                    if isinstance(pt, (ProjectType, str)):
+                        allowed_values.append(str(pt))
+
+                if project_info.type not in allowed_values:
                     self._project_id = None
 
         self._multiselect = multiselect
@@ -322,6 +329,7 @@ class SelectDatasetTree(Widget):
         """
         if not self._multiselect:
             raise ValueError("This method can only be called when multiselect is enabled.")
+        self._select_all_datasets_checkbox.uncheck()
         self._select_dataset.set_selected_by_id(dataset_ids)
 
     def team_changed(self, func: Callable) -> Callable:

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/nn/inference/cache.py

@@ -790,14 +790,20 @@ class InferenceImageCache:
                 try:
                     frame = self.get_frame_from_cache(video_id, hash_or_id)
                 except Exception as e:
-                    logger.error(f"Error retrieving frame from cache: {e}", exc_info=True)
+                    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: {e}", exc_info=True)
+                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