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

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

@@ -0,0 +1,165 @@
+from typing import Any, Dict, List
+
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    Container,
+    OneOf,
+    RadioGroup,
+    RadioTable,
+    SelectDatasetTree,
+    Text,
+)
+from supervisely.project.project import ProjectType
+
+
+class InputSelector:
+    title = "Select Input"
+    description = "Select input data on which to run model for prediction"
+    lock_message = None
+
+    def __init__(self, workspace_id: int):
+        # Init Step
+        self.workspace_id = workspace_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
+        # 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=False,
+            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(
+            flat=True,
+            select_all_datasets=False,
+            allowed_project_types=[ProjectType.VIDEOS],
+            always_open=False,
+            compact=False,
+            team_is_selectable=False,
+            workspace_is_selectable=False,
+            show_select_all_datasets_checkbox=False,
+        )
+        self.select_video = RadioTable(columns=["id", "name", "dataset"], rows=[])
+        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,
+        )
+        # ----------------------------------- #
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return [
+            self.select_dataset_for_images,
+            self.select_dataset_for_video,
+            self.select_video,
+            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:
+            return {"video_id": self.select_video.get_selected_row()}
+
+    def load_from_json(self, data):
+        if "project_id" in data:
+            self.select_dataset_for_images.set_project_id(data["project_id"])
+            self.select_dataset_for_images.select_all()
+            self.radio.set_value(ProjectType.IMAGES.value)
+        if "dataset_ids" in data:
+            self.select_dataset_for_images.set_dataset_ids(data["dataset_ids"])
+            self.radio.set_value(ProjectType.IMAGES.value)
+        if "video_id" in data:
+            self.select_video.select_row_by_value("id", data["video_id"])
+            self.radio.set_value(ProjectType.VIDEOS.value)
+
+    def validate_step(self) -> bool:
+        self.validator_text.hide()
+        if self.radio.get_value() == ProjectType.IMAGES.value:
+            if len(self.select_dataset_for_images.get_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 self.select_dataset_for_video.get_selected_id() is None:
+                self.validator_text.set(text="Select a dataset", status="error")
+                self.validator_text.show()
+                return False
+            if len(self.select_video.rows) == 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_row() == []:
+                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,79 @@
+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 = "Select 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()
+        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.card.lock()
+        # ----------------------------------- #
+
+    @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,139 @@
+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,
+    Progress,
+    ProjectThumbnail,
+    Text,
+)
+
+
+class OutputSelector:
+    title = "Select Output"
+    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.",
+        )
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.project_name_field])
+        # ----------------------------------- #
+
+        # 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()
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.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,
+        )
+        self.card.lock()
+        # ----------------------------------- #
+
+    @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 = {}
+        settings["project_name"] = self.project_name_input.get_value()
+        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)
+
+    def validate_step(self) -> bool:
+        self.validator_text.hide()
+        if 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

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"
+        )

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

@@ -0,0 +1,184 @@
+from typing import Any, Dict, List
+
+import yaml
+
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    Checkbox,
+    Container,
+    Editor,
+    Field,
+    Input,
+    Select,
+    Text,
+)
+
+
+class InferenceMode:
+    FULL_IMAGE = "Full Image"
+    SLIDING_WINDOW = "Sliding Window"
+
+
+class AddPredictionsMode:
+    MERGE_WITH_EXISTING_LABELS = "Merge with existing labels"
+    REPLACE_EXISTING_LABELS = "Replace existing labels"
+    REPLACE_EXISTING_LABELS_AND_SAVE_IMAGE_TAGS = "Replace existing labels and save image tags"
+
+
+class SettingsSelector:
+    title = "Settings Selector"
+    description = "Select additional settings for model inference"
+    lock_message = "Select previous step to unlock"
+
+    def __init__(self):
+        # Init Step
+        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.inference_mode_selector = None
+        self.inference_mode_field = None
+        self.model_prediction_suffix_input = None
+        self.model_prediction_suffix_field = None
+        # self.model_prediction_suffix_checkbox = None
+        self.predictions_mode_selector = None
+        self.predictions_mode_field = None
+        self.inference_settings = None
+        # -------------------------------- #
+
+        # Inference Mode
+        self.inference_modes = [InferenceMode.FULL_IMAGE, InferenceMode.SLIDING_WINDOW]
+        self.inference_mode_selector = Select(
+            items=[Select.Item(mode) for mode in self.inference_modes]
+        )
+        self.inference_mode_selector.set_value(self.inference_modes[0])
+        self.inference_mode_field = Field(
+            content=self.inference_mode_selector,
+            title="Inference mode",
+            description="Select how to process images: full images or using sliding window.",
+        )
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.inference_mode_field])
+        # ----------------------------------- #
+
+        # Class / Tag Suffix
+        self.model_prediction_suffix_input = Input(
+            value="_model", minlength=1, placeholder="Enter suffix e.g: _model"
+        )
+        self.model_prediction_suffix_field = Field(
+            content=self.model_prediction_suffix_input,
+            title="Class and tag suffix",
+            description=(
+                "Suffix that will be added to conflicting class and tag names. "
+                "E.g. your project has a class 'person' with shape 'bitmap' and model has class 'person' with shape 'rectangle', "
+                "then suffix will be added to the model predictions to avoid conflicts. E.g. 'person_model'."
+            ),
+        )
+        # self.model_prediction_suffix_checkbox = Checkbox("Always add suffix to model predictions")
+        # Add widgets to display ------------ #
+        self.display_widgets.extend(
+            [self.model_prediction_suffix_field]  # , self.model_prediction_suffix_checkbox]
+        )
+        # ----------------------------------- #
+
+        # Prediction Mode
+        self.prediction_modes = [
+            AddPredictionsMode.MERGE_WITH_EXISTING_LABELS,
+            AddPredictionsMode.REPLACE_EXISTING_LABELS,
+            # AddPredictionsMode.REPLACE_EXISTING_LABELS_AND_SAVE_IMAGE_TAGS, # @TODO: Implement later
+        ]
+        self.predictions_mode_selector = Select(
+            items=[Select.Item(mode) for mode in self.prediction_modes]
+        )
+        self.predictions_mode_selector.set_value(self.prediction_modes[0])
+        self.predictions_mode_field = Field(
+            content=self.predictions_mode_selector,
+            title="Add predictions mode",
+            description="Select how to add predictions to the project: by merging with existing labels or by replacing them.",
+        )
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.predictions_mode_field])
+        # ----------------------------------- #
+
+        # Inference Settings
+        self.inference_settings = Editor("", language_mode="yaml", height_px=300)
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.inference_settings])
+        # ----------------------------------- #
+
+        # 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.card.lock()
+        # ----------------------------------- #
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return [
+            self.inference_mode_selector,
+            self.model_prediction_suffix_input,
+            # self.model_prediction_suffix_checkbox,
+            self.predictions_mode_selector,
+            self.inference_settings,
+        ]
+
+    def set_inference_settings(self, settings: Dict[str, Any]):
+        if isinstance(settings, str):
+            self.inference_settings.set_text(settings)
+        else:
+            self.inference_settings.set_text(yaml.safe_dump(settings))
+
+    def get_inference_settings(self) -> Dict:
+        settings = yaml.safe_load(self.inference_settings.get_text())
+        if settings:
+            return settings
+        return {}
+
+    def get_settings(self) -> Dict[str, Any]:
+        return {
+            "inference_mode": self.inference_mode_selector.get_value(),
+            "model_prediction_suffix": self.model_prediction_suffix_input.get_value(),
+            "predictions_mode": self.predictions_mode_selector.get_value(),
+            "inference_settings": self.get_inference_settings(),
+        }
+
+    def load_from_json(self, data):
+        inference_mode = data.get("inference_mode", None)
+        if inference_mode:
+            self.inference_mode_selector.set_value(inference_mode)
+
+        model_prediction_suffix = data.get("model_prediction_suffix", None)
+        if model_prediction_suffix is not None:
+            self.model_prediction_suffix_input.set_value(model_prediction_suffix)
+
+        predictions_mode = data.get("predictions_mode", None)
+        if predictions_mode:
+            self.predictions_mode_selector.set_value(predictions_mode)
+
+        inference_settings = data.get("inference_settings", None)
+        if inference_settings is not None:
+            self.set_inference_settings(inference_settings)
+
+    def validate_step(self) -> bool:
+        return True