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

supervisely/app/widgets/dialog/template.html

@@ -2,8 +2,9 @@
   :title=data.{{{widget.widget_id}}}.title
   :size=data.{{{widget.widget_id}}}.size
   :visible.sync="state.{{{widget.widget_id}}}.visible"
+  @close="post('/{{{widget.widget_id}}}/close_cb');"
 >
   <div>
     {{{widget._content}}}
   </div>
-</el-dialog>
+</el-dialog>

supervisely/app/widgets/experiment_selector/experiment_selector.py

@@ -721,6 +721,14 @@ class ExperimentSelector(Widget):
     def enable(self):
         return self.table.enable()
 
+    @property
+    def loading(self):
+        return self.table.loading
+
+    @loading.setter
+    def loading(self, value: bool):
+        self.table.loading = value
+
     def get_json_data(self):
         return {}
 

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,7 +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"] = 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
@@ -295,7 +300,7 @@ class FastTable(Widget):
         :rtype: Dict[str, Any]
         """
         return {
-            "data": 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,
@@ -307,7 +312,7 @@ class FastTable(Widget):
                 "isRadio": self._is_radio,
                 "isRowSelectable": self._is_selectable,
                 "maxSelectedRows": self._max_selected_rows,
-                "searchPosition": self._search_position
+                "searchPosition": self._search_position,
             },
             "pageSize": self._page_size,
             "showHeader": self._show_header,
@@ -490,7 +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"] = 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
@@ -519,7 +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"] = 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()
@@ -578,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:
@@ -621,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
@@ -633,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)
 
@@ -644,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)
 
@@ -715,7 +739,25 @@ 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"] = 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()
+
+    def add_rows(self, rows: List):
+        for row in rows:
+            self._validate_table_sizes(row)
+            self._validate_row_values_types(row)
+        self._source_data = pd.concat(
+            [self._source_data, pd.DataFrame(rows, columns=self._source_data.columns)]
+        ).reset_index(drop=True)
+        (
+            self._parsed_source_data,
+            self._sliced_data,
+            self._parsed_active_data,
+        ) = self._prepare_working_data()
+        self._rows_total = len(self._parsed_source_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()
@@ -743,7 +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"] = 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
@@ -755,7 +797,7 @@ class FastTable(Widget):
         self._sliced_data = pd.DataFrame(columns=self._columns_first_idx)
         self._parsed_active_data = {"data": [], "columns": []}
         self._rows_total = 0
-        DataJson()[self.widget_id]["data"] = []
+        DataJson()[self.widget_id]["data"] = {}
         DataJson()[self.widget_id]["total"] = 0
         DataJson().send_changes()
         self._maybe_update_selected_row()
@@ -856,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:
@@ -867,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
@@ -894,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}",
@@ -925,7 +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"] = 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()
@@ -1030,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
 
@@ -1206,7 +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"] = 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()
@@ -1275,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
@@ -1288,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:
@@ -1299,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
@@ -1312,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:
@@ -1335,4 +1425,4 @@ class FastTable(Widget):
             else:
                 raise TypeError(f"Column name must be a string or a tuple, got {type(col)}")
 
-        self._validate_sort_attrs()
+        self._validate_sort_attrs()

supervisely/app/widgets/fast_table/template.html

@@ -11,7 +11,7 @@
   :project-meta="data.{{{widget.widget_id}}}.projectMeta"
   :sort.sync="state.{{{widget.widget_id}}}.sort"
   :search.sync="state.{{{widget.widget_id}}}.search"
-  :data="data.{{{widget.widget_id}}}.data"
+  :data="Object.values(data.{{{widget.widget_id}}}.data || [])"
   :show-header="data.{{{widget.widget_id}}}.showHeader"
   :selected-rows="state.{{{widget.widget_id}}}.selectedRows"
   :selected-radio-idx="state.{{{widget.widget_id}}}.selectedRows && state.{{{widget.widget_id}}}.selectedRows.length > 0 ? state.{{{widget.widget_id}}}.selectedRows[0].idx : null"

supervisely/app/widgets/radio_tabs/radio_tabs.py

@@ -1,5 +1,9 @@
-from typing import List, Optional, Dict
+import traceback
+from typing import Dict, List, Optional
+
+from supervisely._utils import logger
 from supervisely.app import StateJson
+from supervisely.app.content import DataJson
 from supervisely.app.widgets import Widget
 
 
@@ -65,7 +69,7 @@ class RadioTabs(Widget):
         return _value_changed
 
     def get_json_data(self) -> Dict:
-        return {}
+        return {"tabsOptions": {item.name: {"disabled": False} for item in self._items}}
 
     def get_json_state(self) -> Dict:
         return {"value": self._value}
@@ -77,3 +81,15 @@ class RadioTabs(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()

supervisely/app/widgets/radio_tabs/template.html

@@ -20,6 +20,7 @@
     {% for tab_pane in widget._items %}
     <el-tab-pane
         name="{{{tab_pane.name}}}"
+        :disabled="data.{{{widget.widget_id}}}.tabsOptions['{{{tab_pane.name}}}'].disabled"
     >
         <el-radio 
             slot="label" 

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:
@@ -160,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__)
@@ -308,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.
 
@@ -353,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)
@@ -390,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.
@@ -412,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.
 
@@ -421,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.
 
@@ -435,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(),
@@ -446,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),
@@ -456,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),
@@ -464,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.