supervisely 6.73.410__py3-none-any.whl → 6.73.470__py3-none-any.whl

supervisely/app/widgets/select_dataset_tree/select_dataset_tree.py

@@ -5,6 +5,7 @@ from supervisely.api.api import Api
 from supervisely.app.widgets import Widget
 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.tree_select.tree_select import TreeSelect
 from supervisely.project.project_type import ProjectType
@@ -97,6 +98,7 @@ class SelectDatasetTree(Widget):
         widget_id: Union[str, None] = None,
         show_select_all_datasets_checkbox: bool = True,
         width: int = 193,
+        show_selectors_labels: bool = False,
     ):
         self._api = Api.from_env()
 
@@ -114,11 +116,29 @@ class SelectDatasetTree(Widget):
         # Using environment variables to set the default values if they are not provided.
         self._project_id = project_id or env.project_id(raise_not_found=False)
         self._dataset_id = default_id or env.dataset_id(raise_not_found=False)
+        if self._project_id:
+            project_info = self._api.project.get_info_by_id(self._project_id)
+            if allowed_project_types is not None:
+                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
         self._compact = compact
         self._append_to_body = append_to_body
 
+        # User-defined callbacks
+        self._team_changed_callbacks = []
+        self._workspace_changed_callbacks = []
+        self._project_changed_callbacks = []
+
         # Extract values from Enum to match the .type property of the ProjectInfo object.
         self._project_types = None
         if allowed_project_types is not None:
@@ -141,6 +161,10 @@ class SelectDatasetTree(Widget):
         self._select_dataset = None
         self._width = width
 
+        # Flags
+        self._team_is_selectable = team_is_selectable
+        self._workspace_is_selectable = workspace_is_selectable
+
         # List of widgets will be used to create a Container.
         self._widgets = []
 
@@ -156,6 +180,7 @@ class SelectDatasetTree(Widget):
         if show_select_all_datasets_checkbox:
             self._create_select_all_datasets_checkbox(select_all_datasets)
 
+        self._show_selectors_labels = show_selectors_labels
         # Group the selectors and the dataset selector into a container.
         self._content = Container(self._widgets)
         super().__init__(widget_id=widget_id, file_path=__file__)
@@ -165,11 +190,25 @@ class SelectDatasetTree(Widget):
         for widget in self._widgets:
             widget.disable()
 
+        if self._select_team is not None:
+            if not self._team_is_selectable:
+                self._select_team.disable()
+        if self._select_workspace is not None:
+            if not self._workspace_is_selectable:
+                self._select_workspace.disable()
+
     def enable(self) -> None:
         """Enable the widget in the UI."""
         for widget in self._widgets:
             widget.enable()
 
+        if self._select_team is not None:
+            if not self._team_is_selectable:
+                self._select_team.disable()
+        if self._select_workspace is not None:
+            if not self._workspace_is_selectable:
+                self._select_workspace.disable()
+
     @property
     def team_id(self) -> int:
         """The ID of the team selected in the widget.
@@ -290,8 +329,30 @@ 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:
+        """Decorator to set the callback function for the team changed event."""
+        if self._compact:
+            raise ValueError("callback 'team_changed' is not available in compact mode.")
+        self._team_changed_callbacks.append(func)
+        return func
+
+    def workspace_changed(self, func: Callable) -> Callable:
+        """Decorator to set the callback function for the workspace changed event."""
+        if self._compact:
+            raise ValueError("callback 'workspace_changed' is not available in compact mode.")
+        self._workspace_changed_callbacks.append(func)
+        return func
+
+    def project_changed(self, func: Callable) -> Callable:
+        """Decorator to set the callback function for the project changed event."""
+        if self._compact:
+            raise ValueError("callback 'project_changed' is not available in compact mode.")
+        self._project_changed_callbacks.append(func)
+        return func
+
     def value_changed(self, func: Callable) -> Callable:
         """Decorator to set the callback function for the value changed event.
 
@@ -335,13 +396,13 @@ class SelectDatasetTree(Widget):
 
             if checked:
                 self._select_dataset.select_all()
-                self._select_dataset.hide()
+                self._select_dataset_field.hide()
             else:
                 self._select_dataset.clear_selected()
-                self._select_dataset.show()
+                self._select_dataset_field.show()
 
         if select_all_datasets:
-            self._select_dataset.hide()
+            self._select_dataset_field.hide()
             select_all_datasets_checkbox.check()
 
         self._widgets.append(select_all_datasets_checkbox)
@@ -372,9 +433,10 @@ class SelectDatasetTree(Widget):
             self._select_dataset.set_selected_by_id(self._dataset_id)
         if select_all_datasets:
             self._select_dataset.select_all()
+        self._select_dataset_field = Field(self._select_dataset, title="Dataset")
 
         # Adding the dataset selector to the list of widgets to be added to the container.
-        self._widgets.append(self._select_dataset)
+        self._widgets.append(self._select_dataset_field)
 
     def _create_selectors(self, team_is_selectable: bool, workspace_is_selectable: bool):
         """Create the team, workspace, and project selectors.
@@ -394,6 +456,9 @@ class SelectDatasetTree(Widget):
             self._select_workspace.set(items=self._get_select_items(team_id=team_id))
             self._team_id = team_id
 
+            for callback in self._team_changed_callbacks:
+                callback(team_id)
+
         def workspace_selector_handler(workspace_id: int):
             """Handler function for the event when the workspace selector value changes.
 
@@ -403,6 +468,9 @@ class SelectDatasetTree(Widget):
             self._select_project.set(items=self._get_select_items(workspace_id=workspace_id))
             self._workspace_id = workspace_id
 
+            for callback in self._workspace_changed_callbacks:
+                callback(workspace_id)
+
         def project_selector_handler(project_id: int):
             """Handler function for the event when the project selector value changes.
 
@@ -417,7 +485,10 @@ class SelectDatasetTree(Widget):
                 and self._select_all_datasets_checkbox.is_checked()
             ):
                 self._select_dataset.select_all()
-                self._select_dataset.hide()
+                self._select_dataset_field.hide()
+
+            for callback in self._project_changed_callbacks:
+                callback(project_id)
 
         self._select_team = Select(
             items=self._get_select_items(),
@@ -428,6 +499,7 @@ class SelectDatasetTree(Widget):
         self._select_team.set_value(self._team_id)
         if not team_is_selectable:
             self._select_team.disable()
+        self._select_team_field = Field(self._select_team, title="Team")
 
         self._select_workspace = Select(
             items=self._get_select_items(team_id=self._team_id),
@@ -438,6 +510,7 @@ class SelectDatasetTree(Widget):
         self._select_workspace.set_value(self._workspace_id)
         if not workspace_is_selectable:
             self._select_workspace.disable()
+        self._select_workspace_field = Field(self._select_workspace, title="Workspace")
 
         self._select_project = Select(
             items=self._get_select_items(workspace_id=self._workspace_id),
@@ -446,14 +519,17 @@ class SelectDatasetTree(Widget):
             width_px=self._width,
         )
         self._select_project.set_value(self._project_id)
+        self._select_project_field = Field(self._select_project, title="Project")
 
-        # Register the event handlers.
+        # Register the event handlers._select_project
         self._select_team.value_changed(team_selector_handler)
         self._select_workspace.value_changed(workspace_selector_handler)
         self._select_project.value_changed(project_selector_handler)
 
         # Adding widgets to the list, so they can be added to the container.
-        self._widgets.extend([self._select_team, self._select_workspace, self._select_project])
+        self._widgets.extend(
+            [self._select_team_field, self._select_workspace_field, self._select_project_field]
+        )
 
     def _get_select_items(self, **kwargs) -> List[Select.Item]:
         """Get the list of items for the team, workspace, and project selectors.

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/tabs/tabs.py

@@ -1,9 +1,10 @@
-from typing import List, Optional, Dict
-from supervisely.app import StateJson
-from supervisely.app.widgets import Widget
 import traceback
-from supervisely import logger
+from typing import Dict, List, Optional
 
+from supervisely import logger
+from supervisely.app import StateJson
+from supervisely.app.content import DataJson
+from supervisely.app.widgets import Widget
 
 try:
     from typing import Literal
@@ -34,7 +35,7 @@ class Tabs(Widget):
             raise ValueError("You can specify up to 10 tabs.")
         if len(set(labels)) != len(labels):
             raise ValueError("All of tab labels should be unique.")
-        self._items = []
+        self._items: List[Tabs.TabPane] = []
         for label, widget in zip(labels, contents):
             self._items.append(Tabs.TabPane(label=label, content=widget))
         self._value = labels[0]
@@ -43,7 +44,10 @@ class Tabs(Widget):
         super().__init__(widget_id=widget_id, file_path=__file__)
 
     def get_json_data(self) -> Dict:
-        return {"type": self._type}
+        return {
+            "type": self._type,
+            "tabsOptions": {item.name: {"disabled": False} for item in self._items},
+        }
 
     def get_json_state(self) -> Dict:
         return {"value": self._value}
@@ -56,6 +60,18 @@ class Tabs(Widget):
     def get_active_tab(self) -> str:
         return StateJson()[self.widget_id]["value"]
 
+    def disable_tab(self, tab_name: str):
+        if tab_name not in [item.name for item in self._items]:
+            raise ValueError(f"Tab with name '{tab_name}' does not exist.")
+        DataJson()[self.widget_id]["tabsOptions"][tab_name]["disabled"] = True
+        DataJson().send_changes()
+
+    def enable_tab(self, tab_name: str):
+        if tab_name not in [item.name for item in self._items]:
+            raise ValueError(f"Tab with name '{tab_name}' does not exist.")
+        DataJson()[self.widget_id]["tabsOptions"][tab_name]["disabled"] = False
+        DataJson().send_changes()
+
     def click(self, func):
         route_path = self.get_route_path(Tabs.Routes.CLICK)
         server = self._sly_app.get_server()

supervisely/app/widgets/tabs/template.html

@@ -11,7 +11,11 @@
   %}
 >
   {% for tab_pane in widget._items %}
-  <el-tab-pane label="{{{tab_pane.label}}}" name="{{{tab_pane.name}}}">
+  <el-tab-pane
+    label="{{{tab_pane.label}}}"
+    name="{{{tab_pane.name}}}"
+    :disabled="data.{{{widget.widget_id}}}.tabsOptions['{{{tab_pane.name}}}'].disabled"
+  >
     {{{ tab_pane.content }}}
   </el-tab-pane>
   {% endfor %}

supervisely/app/widgets/transfer/style.css

@@ -0,0 +1,3 @@
+.wide-transfer .el-transfer-panel {
+  width: var(--panel-width, 150px);
+}

supervisely/app/widgets/transfer/template.html

@@ -1,4 +1,6 @@
-<div>
+<link rel="stylesheet" href="./sly/css/app/widgets/transfer/style.css" />
+
+<div class="wide-transfer" style="--panel-width: {{{widget._width}}}px;">
   <el-transfer
     {% if widget._filterable is true %}
     filterable