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

supervisely/nn/inference/predict_app/gui/input_selector.py

@@ -0,0 +1,344 @@
+import threading
+from typing import Any, Dict, List
+
+from supervisely.api.api import Api
+from supervisely.api.dataset_api import DatasetInfo
+from supervisely.api.project_api import ProjectInfo
+from supervisely.api.video.video_api import VideoInfo
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    Container,
+    FastTable,
+    OneOf,
+    RadioGroup,
+    SelectDatasetTree,
+    Text,
+)
+from supervisely.app.widgets.widget import Widget
+from supervisely.project.project import ProjectType
+
+
+class InputSelector:
+    title = "Input data"
+    description = "Select input data on which to run model for prediction"
+    lock_message = None
+
+    def __init__(self, workspace_id: int, api: Api):
+        # Init Step
+        self.workspace_id = workspace_id
+        self.api = api
+        self.display_widgets: List[Any] = []
+        # -------------------------------- #
+
+        # Init Base Widgets
+        self.validator_text = None
+        self.button = None
+        self.container = None
+        self.card = None
+        # -------------------------------- #
+
+        # Init Step Widgets
+        # Images
+        self.select_dataset_for_images = None
+        self.select_image_container = None
+        # Videos
+        self.select_dataset_for_video = None
+        self.select_video = None
+        self.select_video_container = None
+        # Selector
+        self.radio = None
+        self.one_of = None
+        # -------------------------------- #
+
+        # Images
+        self.select_dataset_for_images = SelectDatasetTree(
+            multiselect=True,
+            flat=True,
+            select_all_datasets=True,
+            allowed_project_types=[ProjectType.IMAGES],
+            always_open=False,
+            compact=False,
+            team_is_selectable=False,
+            workspace_is_selectable=False,
+            show_select_all_datasets_checkbox=True,
+        )
+        self.select_image_container = Container(widgets=[self.select_dataset_for_images])
+        self._radio_item_images = RadioGroup.Item(
+            ProjectType.IMAGES.value, "Images", content=self.select_image_container
+        )
+        # -------------------------------- #
+
+        # Videos
+        self.select_dataset_for_video = SelectDatasetTree(
+            multiselect=True,
+            flat=True,
+            select_all_datasets=True,
+            allowed_project_types=[ProjectType.VIDEOS],
+            always_open=False,
+            compact=False,
+            team_is_selectable=False,
+            workspace_is_selectable=False,
+            show_select_all_datasets_checkbox=True,
+        )
+        self._video_table_columns = [
+            "Video id",
+            "Video name",
+            "Size",
+            "Duration",
+            "FPS",
+            "Frames count",
+            "Dataset name",
+            "Dataset id",
+        ]
+        self.select_video = FastTable(
+            columns=self._video_table_columns,
+            is_selectable=True,
+        )
+        self.select_video.hide()
+        self.select_video_container = Container(
+            widgets=[self.select_dataset_for_video, self.select_video]
+        )
+        self._radio_item_videos = RadioGroup.Item(
+            ProjectType.VIDEOS.value, "Videos", content=self.select_video_container
+        )
+        # -------------------------------- #
+
+        # Data type Radio Selector
+        self.radio = RadioGroup(items=[self._radio_item_images, self._radio_item_videos])
+        # self.radio = RadioGroup(items=[self._radio_item_images])
+        # self.radio.hide()
+        self.one_of = OneOf(conditional_widget=self.radio)
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.radio, self.one_of])
+        # ----------------------------------- #
+
+        # Base Widgets
+        self.validator_text = Text("")
+        self.validator_text.hide()
+        self.button = Button("Select")
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.validator_text, self.button])
+        # ----------------------------------- #
+
+        # Card Layout
+        self.container = Container(self.display_widgets)
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=self.container,
+            lock_message=self.lock_message,
+        )
+        # ----------------------------------- #
+
+        self._refresh_table_lock = threading.Lock()
+        self._refresh_table_thread: threading.Thread = None
+        self._refresh_called = False
+
+        @self.radio.value_changed
+        def input_selector_type_changed(value: str):
+            self.validator_text.hide()
+
+        @self.select_dataset_for_images.project_changed
+        def _images_project_changed(project_id):
+            self.validator_text.hide()
+
+        @self.select_dataset_for_images.value_changed
+        def _images_dataset_changed(dataset_ids):
+            self.validator_text.hide()
+
+        @self.select_dataset_for_video.project_changed
+        def _videos_project_changed(project_id: int):
+            self._refresh_video_table_called()
+
+        @self.select_dataset_for_video.value_changed
+        def _videos_dataset_changed(datasets_ids):
+            self._refresh_video_table_called()
+
+    def _refresh_video_table_called(self):
+        with self._refresh_table_lock:
+            self._refresh_called = True
+            if self._refresh_table_thread is None or not self._refresh_table_thread.is_alive():
+                self._refresh_table_thread = threading.Thread(target=self._refresh_video_table_loop)
+        if self._refresh_table_thread is not None and not self._refresh_table_thread.is_alive():
+            self._refresh_table_thread.start()
+
+    def _refresh_video_table_loop(self):
+        while self._refresh_called:
+            with self._refresh_table_lock:
+                self._refresh_called = False
+            self.select_video.loading = True
+            self._refresh_video_table()
+            if not self._refresh_called:
+                self.select_video.loading = False
+
+    def _refresh_video_table(self):
+        self.validator_text.hide()
+        self.select_video.clear()
+        selected_datasets = self.select_dataset_for_video.get_selected_ids()
+        if not selected_datasets:
+            self.select_video.hide()
+        else:
+            rows = []
+            self.select_video.show()
+            for dataset_id in selected_datasets:
+                dataset_info = self.api.dataset.get_info_by_id(dataset_id)
+                videos = self.api.video.get_list(dataset_id)
+                for video in videos:
+                    size = f"{video.frame_height}x{video.frame_width}"
+                    try:
+                        frame_rate = int(video.frames_count / video.duration)
+                    except:
+                        frame_rate = "N/A"
+                    rows.append(
+                        [
+                            video.id,
+                            video.name,
+                            size,
+                            video.duration,
+                            frame_rate,
+                            video.frames_count,
+                            dataset_info.name,
+                            dataset_info.id,
+                        ]
+                    )
+
+            self.select_video.add_rows(rows)
+
+    def select_project(self, project_id: int, project_info: ProjectInfo = None):
+        if project_info is None:
+            project_info = self.api.project.get_info_by_id(project_id)
+        if project_info.type == ProjectType.IMAGES.value:
+            self.select_dataset_for_images.set_project_id(project_id)
+            self.select_dataset_for_images.select_all()
+            self.radio.set_value(ProjectType.IMAGES.value)
+        elif project_info.type == ProjectType.VIDEOS.value:
+            self.select_dataset_for_video.set_project_id(project_id)
+            self.select_dataset_for_video.select_all()
+            self._refresh_video_table()
+            self.select_video.select_rows(list(range(len(self.select_video._rows_total))))
+            self.radio.set_value(ProjectType.VIDEOS.value)
+        else:
+            raise ValueError(f"Project of type {project_info.type} is not supported.")
+
+    def select_datasets(self, dataset_ids: List[int], dataset_infos: List[DatasetInfo] = None):
+        if dataset_infos is None:
+            dataset_infos = [self.api.dataset.get_info_by_id(ds_id) for ds_id in dataset_ids]
+        project_ids = set(ds.project_id for ds in dataset_infos)
+        if len(project_ids) > 1:
+            raise ValueError("Cannot select datasets from different projects")
+        project_id = project_ids.pop()
+        project_info = self.api.project.get_info_by_id(project_id)
+        if project_info.type == ProjectType.IMAGES.value:
+            self.select_dataset_for_images.set_project_id(project_id)
+            self.select_dataset_for_images.set_dataset_ids(dataset_ids)
+            self.radio.set_value(ProjectType.IMAGES.value)
+        elif project_info.type == ProjectType.VIDEOS.value:
+            self.select_dataset_for_video.set_project_id(project_id)
+            self.select_dataset_for_video.set_dataset_ids(dataset_ids)
+            self._refresh_video_table()
+            self.select_video.select_rows(list(range(self.select_video._rows_total)))
+            self.radio.set_value(ProjectType.VIDEOS.value)
+        else:
+            raise ValueError(f"Project of type {project_info.type} is not supported.")
+
+    def select_videos(self, video_ids: List[int], video_infos: List[VideoInfo] = None):
+        if video_infos is None:
+            video_infos = self.api.video.get_info_by_id_batch(video_ids)
+        project_id = video_infos[0].project_id
+        self.select_dataset_for_video.set_project_id(project_id)
+        self.select_dataset_for_video.select_all()
+        self._refresh_video_table()
+        self.select_video.select_row_by_value("id", video_ids)
+        self.radio.set_value(ProjectType.VIDEOS.value)
+
+    def disable(self):
+        for widget in self.widgets_to_disable:
+            widget.disable()
+
+    def enable(self):
+        for widget in self.widgets_to_disable:
+            widget.enable()
+
+    @property
+    def widgets_to_disable(self) -> List[Widget]:
+        return [
+            # Images Selector
+            self.select_dataset_for_images,
+            self.select_dataset_for_images._select_project,
+            self.select_dataset_for_images._select_dataset,
+            # Videos Selector
+            self.select_dataset_for_video,
+            self.select_dataset_for_video._select_project,
+            self.select_dataset_for_video._select_dataset,
+            self.select_video,
+            # Controls
+            self.radio,
+            self.one_of,
+        ]
+
+    def get_settings(self) -> Dict[str, Any]:
+        if self.radio.get_value() == ProjectType.IMAGES.value:
+            return {
+                "project_id": self.select_dataset_for_images.get_selected_project_id(),
+                "dataset_ids": self.select_dataset_for_images.get_selected_ids(),
+            }
+        if self.radio.get_value() == ProjectType.VIDEOS.value:
+            rows = self.select_video.get_selected_rows()
+            if rows:
+                video_ids = [row.row[0] for row in rows]
+            else:
+                video_ids = None
+            return {"video_ids": video_ids}
+
+    def load_from_json(self, data):
+        if "video_ids" in data:
+            video_ids = data["video_ids"]
+            if not video_ids:
+                raise ValueError("Video ids cannot be empty")
+            video_infos = self.api.video.get_info_by_id_batch(video_ids)
+            if not video_infos:
+                raise ValueError(f"Videos with video ids {video_ids} are not found")
+            self.select_videos(video_ids, video_infos)
+        elif "dataset_ids" in data:
+            dataset_ids = data["dataset_ids"]
+            self.select_datasets(dataset_ids)
+        elif "project_id" in data:
+            project_id = data["project_id"]
+            self.select_project(project_id)
+
+    def get_project_id(self) -> int:
+        if self.radio.get_value() == ProjectType.IMAGES.value:
+            return self.select_dataset_for_images.project_id
+        if self.radio.get_value() == ProjectType.VIDEOS.value:
+            return self.select_dataset_for_video.project_id
+        return None
+
+    def validate_step(self) -> bool:
+        self.validator_text.hide()
+        if self.radio.get_value() == ProjectType.IMAGES.value:
+            selected_ids = self.select_dataset_for_images.get_selected_ids()
+            if selected_ids is None:
+                self.validator_text.set(text="Select a project", status="error")
+                self.validator_text.show()
+                return False
+            if len(selected_ids) == 0:
+                self.validator_text.set(text="Select at least one dataset", status="error")
+                self.validator_text.show()
+                return False
+        if self.radio.get_value() == ProjectType.VIDEOS.value:
+            if not self.select_dataset_for_video.get_selected_ids():
+                self.validator_text.set(text="Select a dataset", status="error")
+                self.validator_text.show()
+                return False
+            if self.select_video._rows_total == 0:
+                self.validator_text.set(
+                    text="No videos found in the selected dataset", status="error"
+                )
+                self.validator_text.show()
+                return False
+            if self.select_video.get_selected_rows() == []:
+                self.validator_text.set(text="Select a video", status="error")
+                self.validator_text.show()
+                return False
+        return True

supervisely/nn/inference/predict_app/gui/model_selector.py

@@ -0,0 +1,77 @@
+from typing import Any, Dict, List
+
+from supervisely.api.api import Api
+from supervisely.app.widgets import Button, Card, Container, DeployModel, Text
+
+
+class ModelSelector:
+    title = "Model"
+    description = "Connect to deployed model or deploy new model"
+    lock_message = "Select previous step to unlock"
+
+    def __init__(self, api: Api, team_id: int):
+        # Init Step
+        self.api = api
+        self.team_id = team_id
+        self.display_widgets: List[Any] = []
+        # -------------------------------- #
+
+        # Init Base Widgets
+        self.validator_text = None
+        self.button = None
+        self.container = None
+        self.card = None
+        # -------------------------------- #
+
+        # Init Step Widgets
+        self.model: DeployModel = None
+        # -------------------------------- #
+
+        # Model Selector
+        self.model = DeployModel(api=self.api, team_id=self.team_id)
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.model])
+        # ----------------------------------- #
+
+        # Base Widgets
+        self.validator_text = Text("")
+        self.validator_text.hide()
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.validator_text])
+        # ----------------------------------- #
+
+        # Card Layout
+        self.container = Container(self.display_widgets)
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=self.container,
+            lock_message=self.lock_message,
+        )
+        # ----------------------------------- #
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return [
+            self.model,
+            self.model.connect_button,
+            self.model.deploy_button,
+            self.model.stop_button,
+            self.model.disconnect_button,
+        ]
+
+    def get_settings(self) -> Dict[str, Any]:
+        return self.model.get_deploy_parameters()
+
+    def load_from_json(self, data):
+        self.model.load_from_json(data)
+
+    def validate_step(self) -> bool:
+        self.validator_text.hide()
+
+        if self.model.model_api is None:
+            self.validator_text.set(text="Please connect or deploy a model", status="error")
+            self.validator_text.show()
+            return False
+
+        return True

supervisely/nn/inference/predict_app/gui/output_selector.py

@@ -0,0 +1,179 @@
+from typing import Any, Dict, List
+
+from supervisely import logger
+from supervisely.api.api import Api
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    Checkbox,
+    Container,
+    Field,
+    Input,
+    OneOf,
+    Progress,
+    ProjectThumbnail,
+    RadioGroup,
+    Text,
+)
+from supervisely.project.project_meta import ProjectType
+
+
+class OutputSelector:
+    title = "Result"
+    description = "Select the output mode"
+    lock_message = "Select previous step to unlock"
+
+    def __init__(self, api: Api):
+        # Init Step
+        self.api = api
+        self.display_widgets: List[Any] = []
+        # -------------------------------- #
+
+        # Init Base Widgets
+        self.validator_text = None
+        self.start_button = None
+        self.stop_button = None
+        self.container = None
+        self.card = None
+        # -------------------------------- #
+
+        # Init Step Widgets
+        self.stop_serving_on_finish = None
+        self.stop_self_on_finish = None
+        self.project_name_input = None
+        self.project_name_field = None
+        self.progress = None
+        self.project_thumbnail = None
+        # -------------------------------- #
+
+        # TODO: Implement option later
+        # Stop Apps on Finish
+        # self.stop_serving_on_finish = Checkbox("Stop Serving App on prediction finish", False)
+        # self.stop_self_on_finish = Checkbox("Stop Predict App on prediction finish", True)
+        # Add widgets to display ------------ #
+        # self.display_widgets.extend([self.stop_serving_on_finish, self.stop_self_on_finish])
+        # ----------------------------------- #
+
+        # Project Name
+        self.project_name_input = Input(minlength=1, maxlength=255, placeholder="New Project Name")
+        self.project_name_field = Field(
+            content=self.project_name_input,
+            title="New Project Name",
+            description="Name of the new project to create for the results. The created project will have the same dataset structure as the input project.",
+        )
+        self.skip_annotated_checkbox = Checkbox("Skip annotated items", False)
+        self._tab_names = ["Create New Project", "Update source project"]
+        self._tab_contents = [self.project_name_field, self.skip_annotated_checkbox]
+        self.tabs = RadioGroup(
+            items=[
+                RadioGroup.Item(tab_name, content=tab_content)
+                for tab_name, tab_content in zip(self._tab_names, self._tab_contents)
+            ],
+        )
+        self.oneof = OneOf(self.tabs)
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.tabs, self.oneof])
+        # ----------------------------------- #
+
+        # Base Widgets
+        self.validator_text = Text("", status="text")
+        self.validator_text.hide()
+        self.start_button = Button("Run", icon="zmdi zmdi-play")
+        self.stop_button = Button("Stop", icon="zmdi zmdi-stop")
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.start_button, self.validator_text])
+        # ----------------------------------- #
+
+        # Progress
+        self.progress = Progress(hide_on_finish=False)
+        self.progress.hide()
+        self.secondary_progress = Progress(hide_on_finish=False)
+        self.secondary_progress.hide()
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.progress, self.secondary_progress])
+        # ----------------------------------- #
+
+        # Result
+        self.project_thumbnail = ProjectThumbnail()
+        self.project_thumbnail.hide()
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.project_thumbnail])
+        # ----------------------------------- #
+
+        # Card Layout
+        self.container = Container(self.display_widgets)
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=self.container,
+            lock_message=self.lock_message,
+        )
+        # ----------------------------------- #
+
+    def lock(self):
+        self.card.lock(self.lock_message)
+
+    def unlock(self):
+        self.card.unlock()
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return [self.project_name_input]
+
+    def set_result_thumbnail(self, project_id: int):
+        try:
+            project_info = self.api.project.get_info_by_id(project_id)
+            self.project_thumbnail.set(project_info)
+            self.project_thumbnail.show()
+        except Exception as e:
+            logger.error(f"Failed to set result thumbnail: {str(e)}")
+            self.project_thumbnail.hide()
+
+    def get_settings(self) -> Dict[str, Any]:
+        settings = {}
+        if self.tabs.get_value() == self._tab_names[1]:
+            settings["upload_to_source_project"] = True
+        else:
+            settings["project_name"] = self.project_name_input.get_value()
+        settings["skip_annotated"] = self.skip_annotated_checkbox.is_checked()
+        return settings
+
+    def should_stop_serving_on_finish(self) -> bool:
+        if self.stop_serving_on_finish is not None:
+            return self.stop_serving_on_finish.is_checked()
+        return False
+
+    def should_stop_self_on_finish(self) -> bool:
+        if self.stop_self_on_finish is not None:
+            return self.stop_self_on_finish.is_checked()
+        return True
+
+    def load_from_json(self, data):
+        project_name = data.get("project_name", None)
+        if project_name:
+            self.project_name_input.set_value(project_name)
+        upload_to_source_project = data.get("upload_to_source_project", False)
+        if upload_to_source_project:
+            self.tabs.set_value(self._tab_names[1])
+        else:
+            self.tabs.set_value(self._tab_names[0])
+
+    def validate_step(self) -> bool:
+        self.validator_text.hide()
+        if (
+            self.tabs.get_value() == self._tab_names[0]
+            and self.project_name_input.get_value() == ""
+        ):
+            self.validator_text.set(text="Project name is required", status="error")
+            self.validator_text.show()
+            return False
+
+        return True
+
+    def update_item_type(self, item_type: str):
+        if item_type == ProjectType.IMAGES.value:
+            self.skip_annotated_checkbox.show()
+        elif item_type == ProjectType.VIDEOS.value:
+            self.skip_annotated_checkbox.hide()
+        else:
+            raise ValueError(f"Unsupported item type: {item_type}")

supervisely/nn/inference/predict_app/gui/preview.py

@@ -0,0 +1,93 @@
+import os
+from typing import List, Any, Dict
+
+from supervisely.api.api import Api
+from supervisely.app.widgets import Button, Container, Card, Text, GridGallery
+
+
+class Preview:
+    title = "Preview"
+    description = "Preview the model output"
+    lock_message = None
+
+    def __init__(self, api: Api, static_dir: str):
+        # Init Step
+        self.api = api
+        self.display_widgets: List[Any] = []
+        self.static_dir = static_dir
+        self.inference_settings = None
+        # -------------------------------- #
+
+        # Init Base Widgets
+        self.validator_text = None
+        self.button = None
+        self.container = None
+        self.card = None
+        # -------------------------------- #
+
+        # Init Step Widgets
+        self.gallery = None
+        # -------------------------------- #
+
+        # Preview Directory
+        self.preview_dir = os.path.join(self.static_dir, "preview")
+        os.makedirs(self.preview_dir, exist_ok=True)
+        self.preview_path = os.path.join(self.preview_dir, "preview.jpg")
+        self.peview_url = f"/static/preview/preview.jpg"
+        # ----------------------------------- #
+
+        # Preview Widget
+        self.gallery = GridGallery(
+            2,
+            sync_views=True,
+            enable_zoom=True,
+            resize_on_zoom=True,
+            empty_message="Click 'Preview' to see the model output.",
+        )
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.gallery])
+        # ----------------------------------- #
+
+        # Base Widgets
+        self.validator_text = Text("")
+        self.validator_text.hide()
+        self.button = Button("Preview", icon="zmdi zmdi-eye")
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.validator_text, self.button])
+        # ----------------------------------- #
+
+        # Card Layout
+        self.container = Container(self.display_widgets)
+        self.card = Card(
+            title="Preview",
+            content=self.container,
+            lock_message=self.lock_message,
+        )
+        self.card.lock()
+        # ----------------------------------- #
+
+        @self.button.click
+        def button_click():
+            self.run_preview()
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return [self.gallery]
+
+    def load_from_json(self, data: Dict[str, Any]) -> None:
+        return
+
+    def get_settings(self) -> Dict[str, Any]:
+        return {
+            "preview_path": self.preview_path,
+            "preview_url": self.peview_url,
+            "inference_settings": self.inference_settings,
+        }
+
+    def validate_step(self) -> bool:
+        return True
+
+    def run_preview(self) -> None:
+        raise NotImplementedError(
+            "run_preview must be implemented by subclasses or injected at runtime"
+        )