supervisely 6.73.420__py3-none-any.whl → 6.73.422__py3-none-any.whl

supervisely/app/widgets/experiment_selector/experiment_selector.py

@@ -1,42 +1,52 @@
+import json
 import os
-from collections import defaultdict
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from dataclasses import asdict
-from typing import Any, Callable, Dict, List, Union
-
-from supervisely import env, logger
-from supervisely._utils import abs_url, is_development
-from supervisely.api.api import Api
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
+import pandas as pd
+
+from supervisely import batched
+from supervisely._utils import abs_url, is_development, logger
+from supervisely.api.api import Api, ApiField
 from supervisely.api.project_api import ProjectInfo
-from supervisely.app.content import DataJson, StateJson
-from supervisely.app.widgets import (
-    Container,
-    Flexbox,
-    ProjectThumbnail,
-    Select,
-    Text,
-    Widget,
+from supervisely.app.exceptions import show_dialog
+from supervisely.app.widgets.container.container import Container
+from supervisely.app.widgets.dropdown_checkbox_selector.dropdown_checkbox_selector import (
+    DropdownCheckboxSelector,
 )
+from supervisely.app.widgets.fast_table.fast_table import FastTable
+from supervisely.app.widgets.flexbox.flexbox import Flexbox
+from supervisely.app.widgets.project_thumbnail.project_thumbnail import ProjectThumbnail
+from supervisely.app.widgets.select.select import Select
+from supervisely.app.widgets.text.text import Text
+from supervisely.app.widgets.widget import Widget
+from supervisely.io import env
 from supervisely.io.fs import get_file_name_with_ext
 from supervisely.nn.experiments import ExperimentInfo
-from supervisely.nn.utils import ModelSource
-
-WEIGHTS_DIR = "weights"
-
-COL_ID = "task id".upper()
-COL_MODEL = "model".upper()
-COL_PROJECT = "training data".upper()
-COL_CHECKPOINTS = "checkpoints".upper()
-COL_SESSION = "session".upper()
-COL_BENCHMARK = "benchmark".upper()
-
-columns = [COL_ID, COL_MODEL, COL_PROJECT, COL_CHECKPOINTS, COL_SESSION, COL_BENCHMARK]
 
 
 class ExperimentSelector(Widget):
-    class Routes:
-        TASK_TYPE_CHANGED = "task_type_changed"
-        VALUE_CHANGED = "value_changed"
+    """
+    Widget for selecting experiments from a team.
+    """
+
+    class COLUMN:
+        NAME = "TASK ID"
+        MODEL = "MODEL"
+        TRAINING_DATA = "TRAINING DATA"
+        CHECKPOINTS = "CHECKPOINTS"
+        SESSION = "SESSION"
+        BENCHMARK = "BENCHMARK"
+
+    COLUMNS = [
+        COLUMN.NAME,
+        COLUMN.MODEL,
+        COLUMN.TRAINING_DATA,
+        COLUMN.CHECKPOINTS,
+        COLUMN.SESSION,
+        COLUMN.BENCHMARK,
+    ]
 
     class ModelRow:
         def __init__(
@@ -45,15 +55,19 @@ class ExperimentSelector(Widget):
             team_id: int,
             task_type: str,
             experiment_info: ExperimentInfo,
+            project_info: Optional[ProjectInfo] = None,
         ):
             self._api = api
             self._team_id = team_id
             self._task_type = task_type
             self._experiment_info = experiment_info
+            self._project_info = project_info
 
             task_id = experiment_info.task_id
-            if task_id == "debug-session" or task_id == -1:
+            if task_id == -1:
                 pass
+            elif task_id == "debug-session":
+                task_id = -1
             elif type(task_id) is str:
                 if task_id.isdigit():
                     task_id = int(task_id)
@@ -77,9 +91,7 @@ class ExperimentSelector(Widget):
             if self._training_project_id is None:
                 self._training_project_info = None
             else:
-                self._training_project_info = self._api.project.get_info_by_id(
-                    self._training_project_id
-                )
+                self._training_project_info = self._project_info
 
             # col 4 checkpoints
             self._checkpoints = experiment_info.checkpoints
@@ -143,14 +155,6 @@ class ExperimentSelector(Widget):
         def checkpoints_selector(self) -> Select:
             return self._checkpoints_widget
 
-        @property
-        def experiment_info(self) -> ExperimentInfo:
-            return self._experiment_info
-
-        @property
-        def best_checkpoint(self) -> str:
-            return self.experiment_info.best_checkpoint
-
         @property
         def session_link(self) -> str:
             return self._session_link
@@ -234,17 +238,24 @@ class ExperimentSelector(Widget):
             return model_widget
 
         def _create_training_project_widget(self) -> Union[ProjectThumbnail, Text]:
+            training_project_thumbnail = ProjectThumbnail(
+                self._training_project_info, remove_margins=True
+            )
+            training_project_text = Text(
+                f"<span class='field-description text-muted' style='color: #7f858e'>Project was deleted</span>",
+                "text",
+                font_size=13,
+            )
             if self.training_project_info is not None:
-                training_project_widget = ProjectThumbnail(
-                    self._training_project_info, remove_margins=True
-                )
+                training_project_thumbnail.show()
+                training_project_text.hide()
             else:
-                training_project_widget = Text(
-                    f"<span class='field-description text-muted' style='color: #7f858e'>Project was deleted</span>",
-                    "text",
-                    font_size=13,
-                )
-            return training_project_widget
+                training_project_thumbnail.hide()
+                training_project_text.show()
+            return Container(widgets=[training_project_thumbnail, training_project_text], gap=0)
+
+        def checkpoint_changed(self, checkpoint_value: str):
+            return
 
         def _create_checkpoints_widget(self) -> Select:
             checkpoint_selector_items = []
@@ -253,6 +264,11 @@ class ExperimentSelector(Widget):
             checkpoint_selector = Select(items=checkpoint_selector_items)
             if self._best_checkpoint_value is not None:
                 checkpoint_selector.set_value(self._best_checkpoint)
+
+            @checkpoint_selector.value_changed
+            def on_checkpoint_changed(checkpoint_value: str):
+                self.checkpoint_changed(checkpoint_value)
+
             return checkpoint_selector
 
         def _create_session_widget(self) -> Text:
@@ -284,265 +300,432 @@ class ExperimentSelector(Widget):
                 )
             return benchmark_widget
 
+        def _widget_to_cell_value(self, widget: Widget) -> str:
+            if isinstance(widget, Container):
+                return json.dumps(
+                    {
+                        "widget_id": widget.widget_id,
+                        "widgets": [w.widget_id for w in widget._widgets],
+                    }
+                )
+            else:
+                return json.dumps({"widget_id": widget.widget_id, "widgets": []})
+
+        def to_table_row(self):
+            return [
+                self._widget_to_cell_value(w)
+                for w in [
+                    self._task_widget,
+                    self._model_wiget,
+                    self._training_project_widget,
+                    self._checkpoints_widget,
+                    self._session_widget,
+                    self._benchmark_widget,
+                ]
+            ]
+
+        @classmethod
+        def widgets_templates(cls):
+            checkpoints_template_widget = Select(items=[])
+            checkpoints_template_widget.value_changed(lambda _: None)
+
+            return [
+                # _task_widget
+                Container(widgets=[Text(""), Text("")], gap=0),
+                # _model_wiget
+                Text(""),
+                # _training_project_widget
+                Container(widgets=[ProjectThumbnail(remove_margins=True), Text("")], gap=0),
+                # _checkpoints_widget
+                checkpoints_template_widget,
+                # _session_widget
+                Text(""),
+                # _benchmark_widget
+                Text(""),
+            ]
+
+        def search_text(self) -> str:
+            text = ""
+            text += str(self._task_id)
+            text += str(self._task_date)
+            text += str(self._model_name)
+            if self._training_project_info is not None:
+                text += str(self._training_project_info.name)
+            else:
+                text += "Project was deleted"
+            return text
+
+        def sort_values(self) -> List[int]:
+            # Sort by training project name: real names first (A->Z), deleted projects last
+            if self._training_project_info is not None:
+                training_project_name = (0, self._training_project_info.name.lower())
+            else:
+                training_project_name = (1, "")
+
+            if self._benchmark_report_id == "No evaluation report available":
+                benchmark_report_id = 0
+            else:
+                benchmark_report_id = 1
+
+            return [
+                self._task_id,
+                self._model_name.capitalize(),
+                training_project_name,
+                0,
+                0,
+                benchmark_report_id,
+            ]
+
     def __init__(
         self,
-        team_id: int,
+        api: Api = None,
+        team_id: int = None,
         experiment_infos: List[ExperimentInfo] = [],
         widget_id: str = None,
     ):
-        self._api = Api.from_env()
+        if team_id is None:
+            team_id = env.team_id()
+        self.team_id = team_id
+        if api is None:
+            api = Api()
+        self.api = api
+        self._experiment_infos = experiment_infos
+        self._checkpoint_changed_func = None
+
+        self._rows = []
+        self.table = self._create_table()
+        self._rows_search_texts = []
+        self._rows_sort_values = []
+
+        self._project_infos_map = self._get_project_infos_map(experiment_infos)
+        self.set_experiment_infos(experiment_infos)
+        super().__init__(widget_id=widget_id)
+
+    def _search_function(self, data: pd.DataFrame, search_value: str) -> List[ModelRow]:
+        search_texts = []
+        for idx in data.index:
+            first_col_value = data.loc[idx, self.COLUMNS[0]]
+            if isinstance(first_col_value, pd.Series):
+                first_col_value = first_col_value.iloc[0]
+            original_idx = self._first_column_value_to_index[first_col_value]
+            search_texts.append(self._rows_search_texts[original_idx])
+
+        search_series = pd.Series(search_texts, index=data.index)
+        mask = search_series.str.contains(search_value, case=False, na=False)
+        return data[mask]
+
+    def _sort_function(
+        self, data: pd.DataFrame, column_idx: int, order: str = "asc"
+    ) -> List[ModelRow]:
+        data = data.copy()
+        if column_idx >= len(self._rows_sort_values[0]) if self._rows_sort_values else True:
+            raise IndexError(
+                f"Sorting by column idx = {column_idx} is not possible, your sort values have only {len(self._rows_sort_values[0]) if self._rows_sort_values else 0} columns with idx from 0 to {len(self._rows_sort_values[0]) - 1 if self._rows_sort_values else -1}"
+            )
 
-        self._team_id = team_id
-        self.__debug_row = None
+        if order == "asc":
+            ascending = True
+        else:
+            ascending = False
+
+        try:
+            sort_values = []
+            for idx in data.index:
+                first_col_value = data.loc[idx, self.COLUMNS[0]]
+                if isinstance(first_col_value, pd.Series):
+                    first_col_value = first_col_value.iloc[0]
+                original_idx = self._first_column_value_to_index[first_col_value]
+                sort_values.append(self._rows_sort_values[original_idx][column_idx])
+
+            sort_series = pd.Series(sort_values, index=data.index)
+            sorted_indices = sort_series.sort_values(ascending=ascending).index
+            data = data.loc[sorted_indices]
+            data.reset_index(inplace=True, drop=True)
+
+        except IndexError as e:
+            e.args = (
+                f"Sorting by column idx = {column_idx} is not possible, your sort values have only {len(self._rows_sort_values[0]) if self._rows_sort_values else 0} columns with idx from 0 to {len(self._rows_sort_values[0]) - 1 if self._rows_sort_values else -1}",
+            )
+            raise e
+
+        return data
+
+    def _filter_function(
+        self, data: pd.DataFrame, filter_value: Tuple[List[str], List[str]]
+    ) -> pd.DataFrame:
+        try:
+            frameworks, task_types = filter_value
+
+            filtered_experiments_idxs = set()
+            if not frameworks and not task_types:
+                return data
+
+            for idx, experiment_info in enumerate(self._experiment_infos):
+                should_add = True
+                if frameworks and experiment_info.framework_name not in frameworks:
+                    should_add = False
+                if task_types and experiment_info.task_type not in task_types:
+                    should_add = False
+                if should_add:
+                    filtered_experiments_idxs.add(idx)
+
+            filtered_data = data.iloc[sorted(filtered_experiments_idxs)]
+            filtered_data.reset_index(inplace=True, drop=True)
+            return filtered_data
+        except Exception as e:
+            logger.error(f"Error during filtering: {e}", exc_info=True)
+            show_dialog(title="Filtering Error", description=str(e), status="error")
+            return data
+
+    def _get_frameworks(self):
+        frameworks = set()
+        for experiment_info in self._experiment_infos:
+            frameworks.add(experiment_info.framework_name)
+        return sorted(frameworks)
+
+    def _get_task_types(self):
+        task_types = set()
+        for experiment_info in self._experiment_infos:
+            task_types.add(experiment_info.task_type)
+        return sorted(task_types)
+
+    def _create_table(self) -> FastTable:
+        widgets = self.ModelRow.widgets_templates()
+        columns = []
+        columns_options = []
+        for column_name, widget in zip(self.COLUMNS, widgets):
+            columns.append((column_name, widget))
+            columns_options.append({"customCell": True})
+        columns_options[3].update({"classes": "border border-gray-200 px-2"})
+        columns_options[3].update({"disableSort": True})
+        columns_options[4].update({"disableSort": True})
+        self.framework_filter = DropdownCheckboxSelector(
+            label="Framework",
+            items=[
+                DropdownCheckboxSelector.Item(framework) for framework in self._get_frameworks()
+            ],
+        )
+        self.task_type_filter = DropdownCheckboxSelector(
+            label="Task Type",
+            items=[
+                DropdownCheckboxSelector.Item(task_type) for task_type in self._get_task_types()
+            ],
+        )
+        table = FastTable(
+            columns=columns,
+            columns_options=columns_options,
+            is_radio=True,
+            page_size=10,
+            header_right_content=Container(
+                widgets=[self.framework_filter, self.task_type_filter],
+                gap=10,
+                direction="horizontal",
+            ),
+        )
+        table.set_search(self._search_function)
+        table.set_sort(self._sort_function)
+        table.set_filter(self._filter_function)
 
-        with ThreadPoolExecutor() as executor:
-            future = executor.submit(self._generate_table_rows, experiment_infos)
-            table_rows = future.result()
+        @self.framework_filter.value_changed
+        def on_framework_filter_change(
+            selected_frameworks: List[DropdownCheckboxSelector.Item],
+        ):
+            selected_frameworks = [item.id for item in selected_frameworks]
+            selected_task_types = self.task_type_filter.get_selected()
+            self.table.filter((selected_frameworks, selected_task_types))
 
-        self._columns = columns
-        self._rows = table_rows
-        # self._rows_html = #[row.to_html() for row in self._rows]
+        @self.task_type_filter.value_changed
+        def on_task_type_filter_change(
+            selected_task_types: List[DropdownCheckboxSelector.Item],
+        ):
+            selected_task_types = [item.id for item in selected_task_types]
+            selected_frameworks = self.framework_filter.get_selected()
+            self.table.filter((selected_frameworks, selected_task_types))
 
-        task_types = [task_type for task_type in table_rows]
-        self._rows_html = defaultdict(list)
-        for task_type in table_rows:
-            self._rows_html[task_type].extend(
-                [model_row.to_html() for model_row in table_rows[task_type]]
-            )
+        return table
 
-        self._task_types = self._filter_task_types(task_types)
-        if len(self._task_types) == 0:
-            self.__default_selected_task_type = None
-        else:
-            self.__default_selected_task_type = self._task_types[0]
-
-        self._changes_handled = False
-        self._task_type_changes_handled = False
-        super().__init__(widget_id=widget_id, file_path=__file__)
-
-    @property
-    def columns(self) -> List[str]:
-        return self._columns
-
-    @property
-    def rows(self) -> Dict[str, List[ModelRow]]:
-        return self._rows
-
-    def get_json_data(self) -> Dict:
-        return {
-            "columns": self._columns,
-            "rowsHtml": self._rows_html,
-            "taskTypes": self._task_types,
-        }
-
-    def get_json_state(self) -> Dict:
-        return {
-            "selectedRow": 0,
-            "selectedTaskType": self.__default_selected_task_type,
-        }
-
-    def set_active_task_type(self, task_type: str):
-        if task_type not in self._task_types:
-            raise ValueError(f'Task Type "{task_type}" does not exist')
-        StateJson()[self.widget_id]["selectedTaskType"] = task_type
-        StateJson().send_changes()
-
-    def get_available_task_types(self) -> List[str]:
-        return self._task_types
-
-    def disable_table(self) -> None:
-        for task_type in self._rows:
-            for row in self._rows[task_type]:
-                row.checkpoints_selector.disable()
-        super().disable()
-
-    def enable_table(self) -> None:
-        for task_type in self._rows:
-            for row in self._rows[task_type]:
-                row.checkpoints_selector.enable()
-        super().enable()
+    def _get_project_infos_map(
+        self, experiment_infos: List[ExperimentInfo]
+    ) -> Dict[int, ProjectInfo]:
+        """
+        Returns a map of project IDs to project infos used in the experiment infos.
+        """
+        project_ids = set()
+        for experiment_info in experiment_infos:
+            if experiment_info.project_id is not None:
+                project_ids.add(experiment_info.project_id)
+        project_ids = list(project_ids)
+
+        project_infos_map = {}
+        if project_ids is not None:
+            for batch in batched(project_ids):
+                filters = [
+                    {
+                        ApiField.FIELD: ApiField.ID,
+                        ApiField.OPERATOR: "in",
+                        ApiField.VALUE: batch,
+                    },
+                ]
 
-    def enable(self):
-        self.enable_table()
-        super().enable()
+                fields = [ApiField.IMAGES_COUNT, ApiField.REFERENCE_IMAGE_URL]
+                batch_infos = self.api.project.get_list(
+                    team_id=self.team_id,
+                    filters=filters,
+                    fields=fields,
+                )
+                for info in batch_infos:
+                    project_infos_map[info.id] = info
 
-    def disable(self) -> None:
-        self.disable_table()
-        super().disable()
+        return project_infos_map
 
-    def _generate_table_rows(
-        self, experiment_infos: List[ExperimentInfo]
-    ) -> Dict[str, List[ModelRow]]:
+    def _generate_table_rows(self, experiment_infos: List[ExperimentInfo]) -> List[ModelRow]:
         """Method to generate table rows from remote path to training app save directory"""
 
         def process_experiment_info(experiment_info: ExperimentInfo):
             try:
+                logger.debug(f"Processing experiment info: {experiment_info.task_id}")
+                project_info = self._project_infos_map.get(experiment_info.project_id)
                 model_row = ExperimentSelector.ModelRow(
-                    api=self._api,
-                    team_id=self._team_id,
+                    api=self.api,
+                    team_id=self.team_id,
                     task_type=experiment_info.task_type,
                     experiment_info=experiment_info,
+                    project_info=project_info,
                 )
+
+                def this_row_checkpoint_changed(checkpoint_value: str):
+                    self._checkpoint_changed(model_row, checkpoint_value)
+
+                model_row.checkpoint_changed = this_row_checkpoint_changed
                 return experiment_info.task_type, model_row
             except Exception as e:
                 logger.debug(f"Failed to process experiment info: {experiment_info}")
                 return None, None
 
-        table_rows = defaultdict(list)
-        with ThreadPoolExecutor() as executor:
-            futures = {
-                executor.submit(process_experiment_info, experiment_info): experiment_info
+        table_rows = []
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            futures = [
+                executor.submit(process_experiment_info, experiment_info)
                 for experiment_info in experiment_infos
-            }
+            ]
 
-            for future in as_completed(futures):
+            for future in futures:
                 result = future.result()
                 if result:
                     task_type, model_row = result
                     if task_type is not None and model_row is not None:
-                        if model_row.task_id == "debug-session" or model_row.task_id == -1:
-                            self.__debug_row = (task_type, model_row)
-                            continue
-                        table_rows[task_type].append(model_row)
-        self._sort_table_rows(table_rows)
-        if self.__debug_row and is_development():
-            task_type, model_row = self.__debug_row
-            table_rows[task_type].insert(0, model_row)
-        return table_rows
+                        table_rows.append(model_row)
 
-    def _sort_table_rows(self, table_rows: Dict[str, List[ModelRow]]) -> None:
-        for task_type in table_rows:
-            table_rows[task_type].sort(key=lambda row: int(row.task_id), reverse=True)
-
-    def _filter_task_types(self, task_types: List[str]):
-        sorted_tt = []
-        if "object detection" in task_types:
-            sorted_tt.append("object detection")
-        if "instance segmentation" in task_types:
-            sorted_tt.append("instance segmentation")
-        if "pose estimation" in task_types:
-            sorted_tt.append("pose estimation")
-        other_tasks = sorted(
-            set(task_types)
-            - set(
-                [
-                    "object detection",
-                    "instance segmentation",
-                    "semantic segmentation",
-                    "pose estimation",
-                ]
-            )
-        )
-        sorted_tt.extend(other_tasks)
-        return sorted_tt
+        table_rows.sort(key=lambda x: x.task_id, reverse=True)
+        return table_rows
 
-    def get_selected_row(self, state=StateJson()) -> Union[ModelRow, None]:
-        if len(self._rows) == 0:
-            return
-        widget_actual_state = state[self.widget_id]
-        widget_actual_data = DataJson()[self.widget_id]
-        task_type = widget_actual_state["selectedTaskType"]
-        if widget_actual_state is not None and widget_actual_data is not None:
-            selected_row_index = int(widget_actual_state["selectedRow"])
-            return self._rows[task_type][selected_row_index]
-
-    def get_selected_row_index(self, state=StateJson()) -> Union[int, None]:
-        widget_actual_state = state[self.widget_id]
-        widget_actual_data = DataJson()[self.widget_id]
-        if widget_actual_state is not None and widget_actual_data is not None:
-            return widget_actual_state["selectedRow"]
-
-    def get_selected_task_type(self) -> str:
-        return StateJson()[self.widget_id]["selectedTaskType"]
-
-    def get_selected_experiment_info(self) -> Dict[str, Any]:
-        if len(self._rows) == 0:
-            return
-        selected_row = self.get_selected_row()
-        selected_row_json = asdict(selected_row._experiment_info)
-        return selected_row_json
+    def _update_search_text(self):
+        self._rows_search_texts = [row.search_text() for row in self._rows]
 
-    def get_selected_checkpoint_path(self) -> str:
-        if len(self._rows) == 0:
-            return
-        selected_row = self.get_selected_row()
-        return selected_row.get_selected_checkpoint_path()
+    def _update_sort_values(self):
+        self._rows_sort_values = [row.sort_values() for row in self._rows]
 
-    def get_selected_checkpoint_name(self) -> str:
-        if len(self._rows) == 0:
-            return
-        selected_row = self.get_selected_row()
-        return selected_row.get_selected_checkpoint_name()
+    def _update_value_index_map(self):
+        self._first_column_value_to_index = {}
+        for i, row in self.table._source_data.iterrows():
+            value = row.iloc[0]
+            self._first_column_value_to_index[value] = i
 
-    def get_model_files(self) -> Dict[str, str]:
+    def set_experiment_infos(self, experiment_infos: List[ExperimentInfo]) -> None:
         """
-        Returns a dictionary with full paths to model files in Supervisely Team Files.
+        Updates the experiment infos and regenerates the table rows.
         """
+        table_rows = self._generate_table_rows(experiment_infos)
+        self._rows = table_rows
+        for row in table_rows:
+            self.table.insert_row(row.to_table_row())
+        self._update_value_index_map()
+        self._update_search_text()
+        self._update_sort_values()
+
+    def get_selected_experiment_info(self) -> Union[ExperimentInfo, None]:
+        selected_row = self.table.get_selected_row()
+        if selected_row is None:
+            return None
+        return self._rows[selected_row.row_index]._experiment_info
+
+    def get_selected_experiment_info_json(self) -> Union[dict, None]:
         experiment_info = self.get_selected_experiment_info()
-        artifacts_dir = experiment_info.get("artifacts_dir")
-        model_files = experiment_info.get("model_files", {})
+        if experiment_info is None:
+            return None
+        return experiment_info.to_json()
+
+    def get_selected_checkpoint_name(self) -> Union[str, None]:
+        selected_row = self.table.get_selected_row()
+        if selected_row is None:
+            return None
+        return self._rows[selected_row.row_index].get_selected_checkpoint_name()
+
+    def get_selected_checkpoint_path(self) -> Union[str, None]:
+        selected_row = self.table.get_selected_row()
+        if selected_row is None:
+            return None
+        return self._rows[selected_row.row_index].get_selected_checkpoint_path()
+
+    def set_selected_row_by_experiment_info(self, experiment_info: ExperimentInfo) -> None:
+        for idx, row in enumerate(self._rows):
+            if row._experiment_info.task_id == experiment_info.task_id:
+                self.table.select_row(idx)
+                return
+        raise ValueError(f"Experiment info {experiment_info} not found in the table rows.")
+
+    def _checkpoint_changed(self, row: ModelRow, checkpoint_value: str):
+        if self._checkpoint_changed_func is None:
+            return
+        return self._checkpoint_changed_func(row, checkpoint_value)
 
-        full_model_files = {
-            name: os.path.join(artifacts_dir, file) for name, file in model_files.items()
-        }
-        full_model_files["checkpoint"] = self.get_selected_checkpoint_path()
-        return full_model_files
+    def checkpoint_changed(self, func: Callable[[ModelRow, str], None]):
+        self._checkpoint_changed_func = func
+        return self._checkpoint_changed_func
 
-    def get_deploy_params(self) -> Dict[str, Any]:
-        """
-        Returns a dictionary with deploy parameters except runtime and device keys.
-        """
-        deploy_params = {
-            "model_source": ModelSource.CUSTOM,
-            "model_files": self.get_model_files(),
-            "model_info": self.get_selected_experiment_info(),
-        }
-        return deploy_params
-
-    def set_active_row(self, row_index: int, task_type: str = None) -> None:
-        if task_type is None:
-            task_type = self.get_selected_task_type()
-            self.set_active_task_type(task_type)
-        if row_index < 0 or row_index > len(self._rows[task_type]) - 1:
-            raise ValueError(f'Row with index "{row_index}" does not exist')
-        StateJson()[self.widget_id]["selectedRow"] = row_index
-        StateJson().send_changes()
-
-    def set_by_task_id(self, task_id: int) -> None:
-        for task_type in self._rows:
-            for i, row in enumerate(self._rows[task_type]):
-                if row.task_id == task_id:
-                    self.set_active_task_type(task_type)
-                    self.set_active_row(i, task_type)
-                    return
+    def selection_changed(self, func):
+        def f(selected_row: FastTable.ClickedRow):
+            if selected_row is None:
+                return
+            idx = selected_row.row_index
+            experiment_info = self._rows[idx]._experiment_info
+            func(experiment_info)
+
+        return self.table.selection_changed(f)
 
-    def get_by_task_id(self, task_id: int) -> Union[ModelRow, None]:
-        for task_type in self._rows:
-            for row in self._rows[task_type]:
-                if row.task_id == task_id:
-                    return row
+    def set_selected_checkpoint_by_name(self, checkpoint_name: str):
+        selected_row = self.table.get_selected_row()
+        if selected_row is None:
+            return
+        self._rows[selected_row.row_index].set_selected_checkpoint_by_name(checkpoint_name)
+
+    def set_selected_row_by_task_id(self, task_id: int):
+        for idx, row in enumerate(self._rows):
+            if row._experiment_info.task_id == task_id:
+                self.table.select_row(idx)
+                return
+        raise ValueError(f"Experiment info with task id {task_id} not found in the table rows.")
+
+    def get_selected_row_by_task_id(self, task_id: int):
+        for idx, row in enumerate(self._rows):
+            if row._experiment_info.task_id == task_id:
+                return row
         return None
 
-    def task_type_changed(self, func: Callable):
-        route_path = self.get_route_path(ExperimentSelector.Routes.TASK_TYPE_CHANGED)
-        server = self._sly_app.get_server()
-        self._task_type_changes_handled = True
+    def search(self, search_value: str):
+        self.table.search(search_value)
 
-        @server.post(route_path)
-        def _task_type_changed():
-            res = self.get_selected_task_type()
-            func(res)
+    def disable(self):
+        return self.table.disable()
 
-        return _task_type_changed
+    def enable(self):
+        return self.table.enable()
 
-    def value_changed(self, func: Callable):
-        route_path = self.get_route_path(ExperimentSelector.Routes.VALUE_CHANGED)
-        server = self._sly_app.get_server()
-        self._changes_handled = True
+    def get_json_data(self):
+        return {}
 
-        @server.post(route_path)
-        def _value_changed():
-            res = self.get_selected_row()
-            func(res)
+    def get_json_state(self):
+        return {}
 
-        return _value_changed
+    def to_html(self):
+        return self.table.to_html()