supervisely 6.73.456__py3-none-any.whl → 6.73.458__py3-none-any.whl

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

@@ -1,163 +1,156 @@
-import random
+import json
 import time
+from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
 import yaml
 
 from supervisely._utils import is_development, logger
-from supervisely.annotation.annotation import Annotation
-from supervisely.annotation.label import Label
 from supervisely.api.api import Api
+from supervisely.api.image_api import ImageInfo
 from supervisely.api.video.video_api import VideoInfo
 from supervisely.app.widgets import Button, Card, Container, Stepper, Widget
+from supervisely.geometry.any_geometry import AnyGeometry
 from supervisely.io import env
+from supervisely.nn.inference.inference import update_meta_and_ann_for_video_annotation
 from supervisely.nn.inference.predict_app.gui.classes_selector import ClassesSelector
 from supervisely.nn.inference.predict_app.gui.input_selector import InputSelector
 from supervisely.nn.inference.predict_app.gui.model_selector import ModelSelector
 from supervisely.nn.inference.predict_app.gui.output_selector import OutputSelector
-from supervisely.nn.inference.predict_app.gui.preview import Preview
 from supervisely.nn.inference.predict_app.gui.settings_selector import (
     AddPredictionsMode,
     SettingsSelector,
 )
 from supervisely.nn.inference.predict_app.gui.tags_selector import TagsSelector
 from supervisely.nn.inference.predict_app.gui.utils import (
-    copy_project,
+    copy_items_to_project,
+    create_project,
     disable_enable,
-    set_stepper_step,
-    wrap_button_click,
+    update_custom_button_params,
+    video_annotation_from_predictions,
 )
 from supervisely.nn.model.model_api import ModelAPI
 from supervisely.nn.model.prediction import Prediction
 from supervisely.project.project_meta import ProjectMeta
+from supervisely.project.project_type import ProjectType
 from supervisely.video_annotation.key_id_map import KeyIdMap
 from supervisely.video_annotation.video_annotation import VideoAnnotation
 
 
 class StepFlow:
-
-    def __init__(self, stepper: Stepper):
-        self.stepper = stepper
+    def __init__(self):
+        self._stepper = None
         self.steps = {}
-        self.step_sequence = []
+        self.steps_sequence = []
 
-    def register_step(
+    def add_step(
         self,
         name: str,
-        card: Card,
+        widget: Widget,
+        on_select: Optional[Callable] = None,
+        on_reactivate: Optional[Callable] = None,
+        depends_on: Optional[List[Widget]] = None,
+        on_lock: Optional[Callable] = None,
+        on_unlock: Optional[Callable] = None,
         button: Optional[Button] = None,
-        widgets_to_disable: Optional[List[Widget]] = None,
-        validation_text: Optional[Widget] = None,
-        validation_func: Optional[Callable] = None,
         position: Optional[int] = None,
-    ) -> "StepFlow":
+    ):
+        if depends_on is None:
+            depends_on = []
         self.steps[name] = {
-            "card": card,
+            "widget": widget,
+            "on_select": on_select,
+            "on_reactivate": on_reactivate,
+            "depends_on": depends_on,
+            "on_lock": on_lock,
+            "on_unlock": on_unlock,
             "button": button,
-            "widgets_to_disable": widgets_to_disable or [],
-            "validation_text": validation_text,
-            "validation_func": validation_func,
-            "position": position,
-            "next_steps": [],
-            "on_select_click": [],
-            "on_reselect_click": [],
-            "wrapper": None,
-            "has_button": button is not None,
+            "is_selected": False,
+            "is_locked": False,
         }
-
+        if button is not None:
+            self._wrap_button(button, name)
         if position is not None:
-            while len(self.step_sequence) <= position:
-                self.step_sequence.append(None)
-            self.step_sequence[position] = name
-
-        return self
-
-    def set_next_steps(self, step_name: str, next_steps: List[str]) -> "StepFlow":
-        if step_name in self.steps:
-            self.steps[step_name]["next_steps"] = next_steps
-        return self
-
-    def add_on_select_actions(
-        self, step_name: str, actions: List[Callable], is_reselect: bool = False
-    ) -> "StepFlow":
-        if step_name in self.steps:
-            key = "on_reselect_click" if is_reselect else "on_select_click"
-            self.steps[step_name][key].extend(actions)
-        return self
-
-    def build_wrappers(self) -> Dict[str, Callable]:
-        valid_sequence = [s for s in self.step_sequence if s is not None and s in self.steps]
+            self.steps_sequence.insert(position, name)
+        else:
+            self.steps_sequence.append(name)
+        self.update_locks()
 
-        for step_name in reversed(valid_sequence):
+    def _create_stepper(self):
+        widgets = []
+        for step_name in self.steps_sequence:
             step = self.steps[step_name]
+            widgets.append(step["widget"])
+        self._stepper = Stepper(widgets=widgets)
 
-            cards_to_unlock = []
-            for next_step_name in step["next_steps"]:
-                if next_step_name in self.steps:
-                    cards_to_unlock.append(self.steps[next_step_name]["card"])
-
-            callback = None
-            if step["next_steps"] and step["has_button"]:
-                for next_step_name in step["next_steps"]:
-                    if (
-                        next_step_name in self.steps
-                        and self.steps[next_step_name].get("wrapper")
-                        and self.steps[next_step_name]["has_button"]
-                    ):
-                        callback = self.steps[next_step_name]["wrapper"]
-                        break
-
-            if step["has_button"]:
-                wrapper = wrap_button_click(
-                    button=step["button"],
-                    cards_to_unlock=cards_to_unlock,
-                    widgets_to_disable=step["widgets_to_disable"],
-                    callback=callback,
-                    validation_text=step["validation_text"],
-                    validation_func=step["validation_func"],
-                    on_select_click=step["on_select_click"],
-                    on_reselect_click=step["on_reselect_click"],
-                    collapse_card=None,
-                )
-
-                step["wrapper"] = wrapper
-
-        return {
-            name: self.steps[name]["wrapper"]
-            for name in self.steps
-            if self.steps[name].get("wrapper") and self.steps[name]["has_button"]
-        }
-
-    def setup_button_handlers(self) -> None:
-        positions = {}
-        pos = 1
-
-        for i, step_name in enumerate(self.step_sequence):
-            if step_name is not None and step_name in self.steps:
-                positions[step_name] = pos
-                pos += 1
-
-        for step_name, step in self.steps.items():
-            if step_name in positions and step.get("wrapper") and step["has_button"]:
+    @property
+    def stepper(self):
+        if self._stepper is None:
+            self._create_stepper()
+        return self._stepper
 
-                button = step["button"]
-                wrapper = step["wrapper"]
-                position = positions[step_name]
-                next_position = position + 1
-
-                def create_handler(btn, cb, next_pos):
-                    def handler():
-                        cb()
-                        set_stepper_step(self.stepper, btn, next_pos=next_pos)
-
-                    return handler
+    def update_stepper(self):
+        for i, step_name in enumerate(self.steps_sequence):
+            step = self.steps[step_name]
+            if not step["is_selected"]:
+                self.stepper.set_active_step(i + 1)
+                return
 
-                button.click(create_handler(button, wrapper, next_position))
+    def update_locks(self):
+        for step in self.steps.values():
+            should_lock = False
+            for dep_name in step["depends_on"]:
+                dep = self.steps[dep_name]
+                if not dep["is_selected"]:
+                    should_lock = True
+                    break
+            if should_lock and not step["is_locked"]:
+                if step["on_lock"] is not None:
+                    step["on_lock"]()
+                step["is_locked"] = True
+            if not should_lock and step["is_locked"]:
+                if step["on_unlock"]:
+                    step["on_unlock"]()
+                step["is_locked"] = False
+
+    def _reactivate_dependents(self, step_name: str, visited=None):
+        if visited is None:
+            visited = set()
+        for dep_name, step in self.steps.items():
+            if step_name in step["depends_on"] and not dep_name in visited:
+                self._reactivate_step(dep_name, visited)
+
+    def _reactivate_step(self, step_name: str, visited=None):
+        step = self.steps[step_name]
+        if step["on_reactivate"] is not None:
+            step["on_reactivate"]()
+        step["is_selected"] = False
+        if visited is None:
+            visited = set()
+        self._reactivate_dependents(step_name, visited)
+
+    def reactivate_step(self, step_name: str):
+        self._reactivate_step(step_name)
+        self.update_stepper()
+        self.update_locks()
+
+    def select_step(self, step_name: str):
+        step = self.steps[step_name]
+        if step["on_select"] is not None:
+            step["on_select"]()
+        step["is_selected"] = True
+        self.update_stepper()
+        self.update_locks()
+
+    def select_or_reactivate(self, step_name: str):
+        step = self.steps[step_name]
+        if step["is_selected"]:
+            self.reactivate_step(step_name)
+        else:
+            self.select_step(step_name)
 
-    def build(self) -> Dict[str, Callable]:
-        wrappers = self.build_wrappers()
-        self.setup_button_handlers()
-        return wrappers
+    def _wrap_button(self, button: Button, step_name: str):
+        button.click(lambda: self.select_or_reactivate(step_name))
 
 
 class PredictAppGui:
@@ -169,6 +162,9 @@ class PredictAppGui:
         self.team_id = env.team_id()
         self.workspace_id = env.workspace_id()
         self.project_id = env.project_id(raise_not_found=False)
+        self.project_meta = None
+        if self.project_id:
+            self.project_meta = ProjectMeta.from_json(self.api.project.get_meta(self.project_id))
         # -------------------------------- #
 
         # Flags
@@ -178,73 +174,178 @@ class PredictAppGui:
 
         # GUI
         # Steps
-        self.steps = []
+        self.step_flow = StepFlow()
+        select_params = {"icon": None, "plain": False, "text": "Select"}
+        reselect_params = {"icon": "zmdi zmdi-refresh", "plain": True, "text": "Reselect"}
 
         # 1. Input selector
-        self.input_selector = InputSelector(self.workspace_id)
-        self.steps.append(self.input_selector.card)
+        self.input_selector = InputSelector(self.workspace_id, self.api)
+
+        def _on_input_select():
+            valid = self.input_selector.validate_step()
+            if not valid:
+                return
+            current_item_type = self.input_selector.radio.get_value()
+            self.update_item_type()
+            if self.model_api:
+                if current_item_type == self.input_selector.radio.get_value():
+                    inference_settings = self.model_api.get_settings()
+                    self.settings_selector.set_inference_settings(inference_settings)
+
+                    if self.input_selector.radio.get_value() == ProjectType.VIDEOS.value:
+                        try:
+                            tracking_settings = self.model_api.get_tracking_settings()
+                            self.settings_selector.set_tracking_settings(tracking_settings)
+                        except Exception as e:
+                            logger.warning(
+                                "Unable to get tracking settings from the model. Settings defaults"
+                            )
+                            self.settings_selector.set_default_tracking_settings()
+            self.input_selector.disable()
+
+            self.project_id = self.input_selector.get_project_id()
+            if self.project_id:
+                self.project_meta = ProjectMeta.from_json(self.api.project.get_meta(self.project_id))
+            update_custom_button_params(self.input_selector.button, reselect_params)
+
+        def _on_input_reactivate():
+            self.input_selector.enable()
+            update_custom_button_params(self.input_selector.button, select_params)
+
+        self.step_flow.add_step(
+            name="input_selector",
+            widget=self.input_selector.card,
+            on_select=_on_input_select,
+            on_reactivate=_on_input_reactivate,
+            button=self.input_selector.button,
+        )
 
         # 2. Model selector
         self.model_selector = ModelSelector(self.api, self.team_id)
-        self.steps.append(self.model_selector.card)
+
+        self.step_flow.add_step(
+            name="model_selector",
+            widget=self.model_selector.card,
+        )
 
         # 3. Classes selector
-        self.classes_selector = None
-        if True:
-            self.classes_selector = ClassesSelector()
-            self.steps.append(self.classes_selector.card)
+        self.classes_selector = ClassesSelector()
+
+        def _on_classes_select():
+            valid = self.classes_selector.validate_step()
+            if not valid:
+                return
+            self.classes_selector.classes_table.disable()
+
+            # Find conflict between project meta and model meta
+            selected_classes_names = self.classes_selector.get_selected_classes()
+            project_meta = self.project_meta
+            model_meta = self.model_api.get_model_meta()
+
+            has_conflict = False
+            for class_name in selected_classes_names:
+                project_obj_class = project_meta.get_obj_class(class_name)
+                if project_obj_class is None:
+                    continue
+
+                model_obj_class = model_meta.get_obj_class(class_name)
+                if model_obj_class.geometry_type.name() == AnyGeometry.name():
+                    continue
+
+                if project_obj_class.geometry_type.name() == model_obj_class.geometry_type.name():
+                    continue
+
+                has_conflict = True
+                break
+
+            if has_conflict:
+                self.settings_selector.model_prediction_suffix_container.show()
+            else:
+                self.settings_selector.model_prediction_suffix_container.hide()
+            # ------------------------------------------------ #
+
+            update_custom_button_params(self.classes_selector.button, reselect_params)
+
+        def _on_classes_reactivate():
+            self.classes_selector.classes_table.enable()
+            update_custom_button_params(self.classes_selector.button, select_params)
+
+        self.step_flow.add_step(
+            name="classes_selector",
+            widget=self.classes_selector.card,
+            on_select=_on_classes_select,
+            on_reactivate=_on_classes_reactivate,
+            depends_on=["input_selector", "model_selector"],
+            on_lock=self.classes_selector.lock,
+            on_unlock=self.classes_selector.unlock,
+            button=self.classes_selector.button,
+        )
 
         # 4. Tags selector
         self.tags_selector = None
         if False:
             self.tags_selector = TagsSelector()
-            self.steps.append(self.tags_selector.card)
-
-        # 5. Settings selector
-        self.settings_selector = SettingsSelector()
-        self.steps.append(self.settings_selector.card)
+            self.step_flow.add_step("tags_selector", self.tags_selector.card)
+
+        # 5. Settings selector & Preview
+        self.settings_selector = SettingsSelector(
+            api=self.api,
+            static_dir=self.static_dir,
+            model_selector=self.model_selector,
+            input_selector=self.input_selector,
+        )
 
-        # 6. Preview
-        self.preview = None
-        if False:
-            self.preview = Preview(api, static_dir)
-            self.steps.append(self.preview.card)
+        def _on_settings_select():
+            valid = self.settings_selector.validate_step()
+            if not valid:
+                return
+            self.settings_selector.disable()
+            update_custom_button_params(self.settings_selector.button, reselect_params)
+
+        def _on_settings_reactivate():
+            self.settings_selector.enable()
+            update_custom_button_params(self.settings_selector.button, select_params)
+
+        self.step_flow.add_step(
+            name="settings_selector",
+            widget=self.settings_selector.cards_container,
+            on_select=_on_settings_select,
+            on_reactivate=_on_settings_reactivate,
+            depends_on=["input_selector", "model_selector", "classes_selector"],
+            on_lock=self.settings_selector.lock,
+            on_unlock=self.settings_selector.unlock,
+            button=self.settings_selector.button,
+        )
+        self.settings_selector.preview.run_button.disable()
 
-        # 7. Output selector
+        # 6. Output selector
         self.output_selector = OutputSelector(self.api)
-        self.steps.append(self.output_selector.card)
-        # -------------------------------- #
 
-        # Stepper
-        self.stepper = Stepper(widgets=self.steps)
-        # ---------------------------- #
+        self.step_flow.add_step(
+            "output_selector",
+            self.output_selector.card,
+            depends_on=[
+                "input_selector",
+                "model_selector",
+                "classes_selector",
+                # "tags_selector",
+                "settings_selector",
+            ],
+            on_lock=self.output_selector.lock,
+            on_unlock=self.output_selector.unlock,
+        )
+        # -------------------------------- #
 
         # Layout
-        self.layout = Container([self.stepper])
+        self.layout = Container([self.step_flow.stepper])
         # ---------------------------- #
 
-        # Button Utils
-        def deploy_model() -> ModelAPI:
-            self.model_selector.validator_text.hide()
-            model_api = None
-            try:
-                model_api = type(self.model_selector.model).deploy(self.model_selector.model)
-            except:
-                self.output_selector.start_button.disable()
-                raise
-            else:
-                self.output_selector.start_button.enable()
-            return model_api
-
-        # Reimplement deploy method for DeployModel widget
-        self.model_selector.model.deploy = deploy_model
-
         def set_entity_meta():
             model_api = self.model_selector.model.model_api
 
             model_meta = model_api.get_model_meta()
             if self.classes_selector is not None:
-                self.classes_selector.classes_table.set_project_meta(model_meta)
+                self.classes_selector.set_project_meta(model_meta)
                 self.classes_selector.classes_table.show()
             if self.tags_selector is not None:
                 self.tags_selector.tags_table.set_project_meta(model_meta)
@@ -253,13 +354,20 @@ class PredictAppGui:
             inference_settings = model_api.get_settings()
             self.settings_selector.set_inference_settings(inference_settings)
 
-            if self.preview is not None:
-                self.preview.inference_settings = inference_settings
+            if self.input_selector.radio.get_value() == ProjectType.VIDEOS.value:
+                try:
+                    tracking_settings = model_api.get_tracking_settings()
+                    self.settings_selector.set_tracking_settings(tracking_settings)
+                except Exception as e:
+                    logger.warning(
+                        "Unable to get tracking settings from the model. Settings defaults"
+                    )
+                    self.settings_selector.set_default_tracking_settings()
 
         def reset_entity_meta():
             empty_meta = ProjectMeta()
             if self.classes_selector is not None:
-                self.classes_selector.classes_table.set_project_meta(empty_meta)
+                self.classes_selector.set_project_meta(empty_meta)
                 self.classes_selector.classes_table.hide()
             if self.tags_selector is not None:
                 self.tags_selector.tags_table.set_project_meta(empty_meta)
@@ -267,394 +375,478 @@ class PredictAppGui:
 
             self.settings_selector.set_inference_settings("")
 
-            if self.preview is not None:
-                self.preview.inference_settings = None
-
-        def disable_settings_editor():
-            if self.settings_selector.inference_settings.readonly:
-                self.settings_selector.inference_settings.readonly = False
+        def deploy_and_set_step():
+            self.model_selector.validator_text.hide()
+            model_api = type(self.model_selector.model).deploy(self.model_selector.model)
+            if model_api is not None:
+                set_entity_meta()
+                self.step_flow.select_step("model_selector")
             else:
-                self.settings_selector.inference_settings.readonly = True
-
-        def generate_preview():
-            def _get_frame_annotation(
-                video_info: VideoInfo, frame_index: int, project_meta: ProjectMeta
-            ) -> Annotation:
-                video_annotation = VideoAnnotation.from_json(
-                    self.api.video.annotation.download(video_info.id, frame_index),
-                    project_meta=project_meta,
-                    key_id_map=KeyIdMap(),
-                )
-                frame = video_annotation.frames.get(frame_index)
-                img_size = (video_info.frame_height, video_info.frame_width)
-                if frame is None:
-                    return Annotation(img_size)
-                labels = []
-                for figure in frame.figures:
-                    labels.append(Label(figure.geometry, figure.video_object.obj_class))
-                ann = Annotation(img_size, labels=labels)
-                return ann
-
-            if self.preview is None:
-                return
+                reset_entity_meta()
+                self.step_flow.reactivate_step("model_selector")
+            return model_api
 
-            self.preview.validator_text.hide()
-            self.preview.gallery.clean_up()
-            self.preview.gallery.show()
-            self.preview.gallery.loading = True
-            try:
-                items_settings = self.input_selector.get_settings()
-                if "video_id" in items_settings:
-                    video_id = items_settings["video_id"]
-                    video_info = self.api.video.get_info_by_id(video_id)
-                    video_frame = random.randint(0, video_info.frames_count - 1)
-                    self.api.video.frame.download_path(
-                        video_info.id, video_frame, self.preview.preview_path
-                    )
-                    img_url = self.preview.peview_url
-                    project_meta = ProjectMeta.from_json(
-                        self.api.project.get_meta(video_info.project_id)
-                    )
-                    input_ann = _get_frame_annotation(video_info, video_frame, project_meta)
-                    prediction = self.model_selector.model.model_api.predict(
-                        input=self.preview.preview_path, **self.settings_selector.get_settings()
-                    )[0]
-                    output_ann = prediction.annotation
-                else:
-                    if "project_id" in items_settings:
-                        project_id = items_settings["project_id"]
-                        dataset_infos = self.api.dataset.get_list(project_id, recursive=True)
-                        dataset_infos = [ds for ds in dataset_infos if ds.items_count > 0]
-                        if not dataset_infos:
-                            raise ValueError("No datasets with items found in the project.")
-                        dataset_info = random.choice(dataset_infos)
-                    elif "dataset_ids" in items_settings:
-                        dataset_ids = items_settings["dataset_ids"]
-                        dataset_infos = [
-                            self.api.dataset.get_info_by_id(dataset_id)
-                            for dataset_id in dataset_ids
-                        ]
-                        dataset_infos = [ds for ds in dataset_infos if ds.items_count > 0]
-                        if not dataset_infos:
-                            raise ValueError("No items in selected datasets.")
-                        dataset_info = random.choice(dataset_infos)
-                    else:
-                        raise ValueError("No valid item settings found for preview.")
-                    images = self.api.image.get_list(dataset_info.id)
-                    image_info = random.choice(images)
-                    img_url = image_info.preview_url
+        def stop_and_reset_step():
+            type(self.model_selector.model).stop(self.model_selector.model)
+            self.step_flow.reactivate_step("model_selector")
+            reset_entity_meta()
 
-                    project_meta = ProjectMeta.from_json(
-                        self.api.project.get_meta(dataset_info.project_id)
-                    )
-                    input_ann = Annotation.from_json(
-                        self.api.annotation.download(image_info.id).annotation,
-                        project_meta=project_meta,
-                    )
-                    prediction = self.model_selector.model.model_api.predict(
-                        image_id=image_info.id, **self.settings_selector.get_settings()
-                    )[0]
-                    output_ann = prediction.annotation
-
-                self.preview.gallery.append(img_url, input_ann, "Input")
-                self.preview.gallery.append(img_url, output_ann, "Output")
-                self.preview.validator_text.hide()
-                self.preview.gallery.show()
-                return prediction
-            except Exception as e:
-                self.preview.gallery.hide()
-                self.preview.validator_text.set(
-                    text=f"Error during preview: {str(e)}", status="error"
-                )
-                self.preview.validator_text.show()
-                self.preview.gallery.clean_up()
-            finally:
-                self.preview.gallery.loading = False
+        def disconnect_and_reset_step():
+            type(self.model_selector.model).disconnect(self.model_selector.model)
+            self.step_flow.reactivate_step("model_selector")
+            reset_entity_meta()
 
-        # ---------------------------- #
+        # Replace deploy methods for DeployModel widget
+        self.model_selector.model.deploy = deploy_and_set_step
+        self.model_selector.model.stop = stop_and_reset_step
+        self.model_selector.model.disconnect = disconnect_and_reset_step
 
-        # StepFlow callbacks and wiring
-        self.step_flow = StepFlow(self.stepper)
-        position = 0
+        # ------------------------------------------------- #
 
-        # 1. Input selector
-        self.step_flow.register_step(
-            "input_selector",
-            self.input_selector.card,
-            self.input_selector.button,
-            self.input_selector.widgets_to_disable,
-            self.input_selector.validator_text,
-            self.input_selector.validate_step,
-            position=position,
-        )
-        position += 1
+    @property
+    def model_api(self) -> Optional[ModelAPI]:
+        return self.model_selector.model.model_api
 
-        # 2. Model selector
-        self.step_flow.register_step(
-            "model_selector",
-            self.model_selector.card,
-            self.model_selector.button,
-            self.model_selector.widgets_to_disable,
-            self.model_selector.validator_text,
-            self.model_selector.validate_step,
-            position=position,
-        )
-        self.step_flow.add_on_select_actions("model_selector", [set_entity_meta])
-        self.step_flow.add_on_select_actions(
-            "model_selector", [reset_entity_meta], is_reselect=True
-        )
-        position += 1
+    def update_item_type(self):
+        item_type = self.input_selector.radio.get_value()
+        self.settings_selector.update_item_type(item_type)
+        self.output_selector.update_item_type(item_type)
 
-        # 3. Classes selector
-        if self.classes_selector is not None:
-            self.step_flow.register_step(
-                "classes_selector",
-                self.classes_selector.card,
-                self.classes_selector.button,
-                self.classes_selector.widgets_to_disable,
-                self.classes_selector.validator_text,
-                self.classes_selector.validate_step,
-                position=position,
-            )
-            position += 1
+    def _run_videos(self, run_parameters: Dict[str, Any]) -> List[Prediction]:
+        if self.model_api is None:
+            self.set_validator_text("Deploying model...", "info")
+            self.model_selector.model._deploy()
+        if self.model_api is None:
+            logger.error("Model Deployed with an error")
+            raise RuntimeError("Model Deployed with an error")
 
-        # 4. Tags selector
-        if self.tags_selector is not None:
-            self.step_flow.register_step(
-                "tags_selector",
-                self.tags_selector.card,
-                self.tags_selector.button,
-                self.tags_selector.widgets_to_disable,
-                self.tags_selector.validator_text,
-                self.tags_selector.validate_step,
-                position=position,
-            )
-            position += 1
-
-        # 5. Settings selector
-        self.step_flow.register_step(
-            "settings_selector",
-            self.settings_selector.card,
-            self.settings_selector.button,
-            self.settings_selector.widgets_to_disable,
-            self.settings_selector.validator_text,
-            self.settings_selector.validate_step,
-            position=position,
-        )
-        self.step_flow.add_on_select_actions("settings_selector", [disable_settings_editor])
-        self.step_flow.add_on_select_actions("settings_selector", [disable_settings_editor], True)
-        position += 1
-
-        # 6. Preview
-        if self.preview is not None:
-            self.step_flow.register_step(
-                "preview",
-                self.preview.card,
-                self.preview.button,
-                self.preview.widgets_to_disable,
-                self.preview.validator_text,
-                self.preview.validate_step,
-                position=position,
-            ).add_on_select_actions("preview", [generate_preview])
-            position += 1
-
-        # 7. Output selector
-        self.step_flow.register_step(
-            "output_selector",
-            self.output_selector.card,
-            None,
-            self.output_selector.widgets_to_disable,
-            self.output_selector.validator_text,
-            self.output_selector.validate_step,
-            position=position,
-        )
+        self.set_validator_text("Preparing settings for prediction...", "info")
+        if run_parameters is None:
+            run_parameters = self.get_run_parameters()
 
-        # Dependencies Chain
-        has_model_selector = self.model_selector is not None
-        has_classes_selector = self.classes_selector is not None
-        has_tags_selector = self.tags_selector is not None
-        has_preview = self.preview is not None
-
-        # Step 1 -> Step 2
-        prev_step = "input_selector"
-        if has_model_selector:
-            self.step_flow.set_next_steps(prev_step, ["model_selector"])
-            prev_step = "model_selector"
-        # Step 2 -> Step 3
-        if has_classes_selector:
-            self.step_flow.set_next_steps(prev_step, ["classes_selector"])
-            prev_step = "classes_selector"
-        # Step 3 -> Step 4
-        if has_tags_selector:
-            self.step_flow.set_next_steps(prev_step, ["tags_selector"])
-            prev_step = "tags_selector"
-        # Step 4 -> Step 5
-        self.step_flow.set_next_steps(prev_step, ["settings_selector"])
-        prev_step = "settings_selector"
-        # Step 5 -> Step 6
-        if has_preview:
-            self.step_flow.set_next_steps(prev_step, ["preview"])
-            prev_step = "preview"
-        # Step 6 -> Step 7
-        self.step_flow.set_next_steps(prev_step, ["output_selector"])
-
-        # Create all wrappers and set button handlers
-        wrappers = self.step_flow.build()
-
-        self.input_selector_cb = wrappers.get("input_selector")
-        self.classes_selector_cb = wrappers.get("classes_selector")
-        self.tags_selector_cb = wrappers.get("tags_selector")
-        self.model_selector_cb = wrappers.get("model_selector")
-        self.settings_selector_cb = wrappers.get("settings_selector")
-        self.preview_cb = wrappers.get("preview")
-        self.output_selector_cb = wrappers.get("output_selector")
-        # ------------------------------------------------- #
+        input_parameters = run_parameters["input"]
+        input_video_ids = input_parameters["video_ids"]
+        if not input_video_ids:
+            raise ValueError("No video IDs provided for video prediction.")
 
-        # Other Handlers
-        @self.input_selector.radio.value_changed
-        def input_selector_type_changed(value: str):
-            self.input_selector.validator_text.hide()
+        predict_kwargs = {}
+        # Settings
+        settings = run_parameters["settings"]
+        model_prediction_suffix = settings.pop("model_prediction_suffix", "")
+        prediction_mode = settings.pop("predictions_mode")
+        tracking = settings.pop("tracking", False)
+        predict_kwargs.update(settings)
 
-        @self.input_selector.select_dataset_for_video.value_changed
-        def dataset_for_video_changed(dataset_id: int):
-            self.input_selector.select_video.loading = True
-            if dataset_id is None:
-                rows = []
-            else:
-                dataset_info = self.api.dataset.get_info_by_id(dataset_id)
-                videos = self.api.video.get_list(dataset_id)
-                rows = [[video.id, video.name, dataset_info.name] for video in videos]
-            self.input_selector.select_video.rows = rows
-            self.input_selector.select_video.loading = False
+        # Classes
+        classes = run_parameters["classes"]
+        if classes:
+            predict_kwargs["classes"] = classes
 
-        # ------------------------------------------------- #
+        output_parameters = run_parameters["output"]
+        project_name = output_parameters.get("project_name", "")
+        upload_to_source_project = output_parameters.get("upload_to_source_project", False)
+        skip_project_versioning = output_parameters.get("skip_project_versioning", False)
+        skip_annotated = output_parameters.get("skip_annotated", False)
+
+        video_infos_by_project_id: Dict[int, List[VideoInfo]] = {}
+        video_infos_by_dataset_id: Dict[int, List[VideoInfo]] = {}
+        for info in self.api.video.get_info_by_id_batch(input_video_ids):
+            video_infos_by_project_id.setdefault(info.project_id, []).append(info)
+            video_infos_by_dataset_id.setdefault(info.dataset_id, []).append(info)
+        src_project_metas: Dict[int, ProjectMeta] = {}
+        for project_id in video_infos_by_project_id.keys():
+            src_project_metas[project_id] = ProjectMeta.from_json(
+                self.api.project.get_meta(project_id)
+            )
 
-    def run(self, run_parameters: Dict[str, Any] = None) -> List[Prediction]:
-        self.show_validator_text()
-        self.set_validator_text("Preparing settings for prediction...", "info")
-        if run_parameters is None:
-            run_parameters = self.get_run_parameters()
+        video_ids_to_skip = set()
+        if skip_annotated:
+            self.set_validator_text("Checking for already annotated videos...", "info")
+            secondary_pbar = self.output_selector.secondary_progress(
+                message="Checking for already annotated videos...", total=len(input_video_ids)
+            )
+            self.output_selector.secondary_progress.show()
+            for dataset_id, video_infos in video_infos_by_dataset_id.items():
+                annotations = self.api.video.annotation.download_bulk(
+                    dataset_id, [info.id for info in video_infos]
+                )
+                for ann_json, video_info in zip(annotations, video_infos):
+                    if ann_json:
+                        project_meta = src_project_metas[video_info.project_id]
+                        ann = VideoAnnotation.from_json(ann_json, project_meta=project_meta)
+                        if len(ann.figures) > 0:
+                            video_ids_to_skip.add(video_info.id)
+                    secondary_pbar.update()
+            self.output_selector.secondary_progress.hide()
+            if video_ids_to_skip:
+                video_infos_by_project_id = {
+                    pid: [info for info in infos if info.id not in video_ids_to_skip]
+                    for pid, infos in video_infos_by_project_id.items()
+                }
+
+        main_pbar_str = "Processing videos..."
+        if video_ids_to_skip:
+            main_pbar_str += f" (Skipped {len(video_ids_to_skip)} already annotated videos)"
+        total_videos = sum(len(v) for v in video_infos_by_project_id.values())
+        if total_videos == 0:
+            self.set_validator_text(
+                f"No videos to process. Skipped {len(video_ids_to_skip)} already annotated videos",
+                "warning",
+            )
+            return []
+        main_pbar = self.output_selector.progress(message=main_pbar_str, total=total_videos)
+        self.output_selector.progress.show()
+        all_predictictions: List[Prediction] = []
+        for src_project_id, src_video_infos in video_infos_by_project_id.items():
+            if len(src_video_infos) == 0:
+                continue
+            project_info = self.api.project.get_info_by_id(src_project_id)
+            project_validator_text_str = (
+                f"Processing project: {project_info.name} [id: {src_project_id}]"
+            )
+            if upload_to_source_project:
+                if not skip_project_versioning and not is_development():
+                    logger.info("Creating new project version...")
+                    self.set_validator_text(
+                        project_validator_text_str + ": Creating project version",
+                        "info",
+                    )
+                    version_id = self.api.project.version.create(
+                        project_info,
+                        "Created by Predict App. Task Id: " + str(env.task_id()),
+                    )
+                    logger.info("New project version created: " + str(version_id))
+                output_project_id = src_project_id
+                output_videos: List[VideoInfo] = src_video_infos
+            else:
+                self.set_validator_text(
+                    project_validator_text_str + ": Creating project...", "info"
+                )
+                if not project_name:
+                    project_name = project_info.name + " [Predictions]"
+                    logger.warning(
+                        "Project name is empty, using auto-generated name: " + project_name
+                    )
+                with_annotations = prediction_mode in [
+                    AddPredictionsMode.APPEND,
+                    AddPredictionsMode.IOU_MERGE,
+                ]
+                created_project = create_project(
+                    api=self.api,
+                    project_id=src_project_id,
+                    project_name=project_name,
+                    workspace_id=self.workspace_id,
+                    copy_meta=with_annotations,
+                    project_type=ProjectType.VIDEOS,
+                )
+                output_project_id = created_project.id
+                output_videos: List[VideoInfo] = copy_items_to_project(
+                    api=self.api,
+                    src_project_id=src_project_id,
+                    items=src_video_infos,
+                    dst_project_id=created_project.id,
+                    with_annotations=with_annotations,
+                    ds_progress=self.output_selector.secondary_progress,
+                    project_type=ProjectType.VIDEOS,
+                )
 
-        if self.model_selector.model.model_api is None:
-            self.model_selector.model._deploy()
+            self.set_validator_text(
+                project_validator_text_str + ": Merging project meta",
+                "info",
+            )
+            project_meta = src_project_metas[src_project_id]
+            for src_video_info, output_video_info in zip(src_video_infos, output_videos):
+                video_validator_text_str = (
+                    project_validator_text_str
+                    + f", video: {src_video_info.name} [id: {src_video_info.id}]"
+                )
+                self.set_validator_text(
+                    video_validator_text_str + ": Predicting",
+                    "info",
+                )
+                frames_predictions: List[Prediction] = []
+                with self.model_api.predict_detached(
+                    video_id=src_video_info.id,
+                    tqdm=self.output_selector.secondary_progress(),
+                    tracking=tracking,
+                    **predict_kwargs,
+                ) as session:
+                    self.output_selector.secondary_progress.show()
+                    for prediction in session:
+                        if self._stop_flag:
+                            logger.info("Prediction stopped by user.")
+                            raise StopIteration("Stopped by user.")
+                        frames_predictions.append(prediction)
+                    all_predictictions.extend(frames_predictions)
+                    if tracking:
+                        prediction_video_annotation: VideoAnnotation = VideoAnnotation.from_json(
+                            session.final_result["video_ann"],
+                            project_meta=self.model_api.get_model_meta(),
+                        )
+                    else:
+                        prediction_video_annotation = video_annotation_from_predictions(
+                            frames_predictions,
+                            project_meta,
+                            frame_size=(src_video_info.frame_height, src_video_info.frame_width),
+                        )
+                if prediction_video_annotation is None:
+                    logger.warning(
+                        f"No predictions were made for video {src_video_info.name} [id: {src_video_info.id}]"
+                    )
+                    main_pbar.update()
+                    continue
+                self.set_validator_text(
+                    video_validator_text_str + ": Uploading predictions",
+                    "info",
+                )
+                project_meta, prediction_video_annotation, meta_changed = (
+                    update_meta_and_ann_for_video_annotation(
+                        meta=project_meta,
+                        ann=prediction_video_annotation,
+                        model_prediction_suffix=model_prediction_suffix,
+                    )
+                )
+                if meta_changed:
+                    self.api.project.update_meta(output_project_id, project_meta)
+                if upload_to_source_project:
+                    if prediction_mode in [
+                        AddPredictionsMode.REPLACE,
+                        AddPredictionsMode.REPLACE_EXISTING_LABELS_AND_SAVE_IMAGE_TAGS,
+                    ]:
+                        self.output_selector.secondary_progress.hide()
+                        with open("/tmp/prediction_video_annotation.json", "w") as f:
+                            json.dump(prediction_video_annotation.to_json(), f)
+                        self.api.video.annotation.upload_paths(
+                            video_ids=[src_video_info.id],
+                            paths=["/tmp/prediction_video_annotation.json"],
+                            project_meta=project_meta,
+                        )
+                    else:
+                        secondary_pbar = self.output_selector.secondary_progress(
+                            message="Uploading annotations...",
+                            total=len(prediction_video_annotation.figures),
+                        )
+                        self.output_selector.secondary_progress.show()
+                        self.api.video.annotation.append(
+                            video_id=src_video_info.id,
+                            ann=prediction_video_annotation,
+                            key_id_map=KeyIdMap(),
+                            progress_cb=secondary_pbar.update,
+                        )
+                else:
+                    secondary_pbar = self.output_selector.secondary_progress(
+                        message="Uploading annotations...",
+                        total=len(prediction_video_annotation.figures),
+                    )
+                    self.output_selector.secondary_progress.show()
+                    self.api.video.annotation.append(
+                        video_id=output_video_info.id,
+                        ann=prediction_video_annotation,
+                        key_id_map=KeyIdMap(),
+                        progress_cb=secondary_pbar.update,
+                    )
+                main_pbar.update()
+        self.set_validator_text("Project successfully processed", "success")
+        self.output_selector.set_result_thumbnail(output_project_id)
+        return all_predictictions
 
-        model_api = self.model_selector.model.model_api
-        if model_api is None:
+    def _run_images(self, run_parameters: Dict[str, Any] = None) -> List[Prediction]:
+        if self.model_api is None:
+            self.set_validator_text("Deploying model...", "info")
+            self.model_selector.model._deploy()
+        if self.model_api is None:
             logger.error("Model Deployed with an error")
-            self.set_validator_text("Model Deployed with an error", "error")
-            return
+            raise RuntimeError("Model Deployed with an error")
 
-        kwargs = {}
+        self.set_validator_text("Preparing settings for prediction...", "info")
+        if run_parameters is None:
+            run_parameters = self.get_run_parameters()
 
+        predict_kwargs = {}
         # Input
-        # Input would be newely created project
         input_args = {}
         input_parameters = run_parameters["input"]
         input_project_id = input_parameters.get("project_id", None)
-        if input_project_id is None:
-            raise ValueError("Input project ID is required for prediction.")
         input_dataset_ids = input_parameters.get("dataset_ids", [])
         input_image_ids = input_parameters.get("image_ids", [])
-        if not (input_dataset_ids or input_image_ids):
-            raise ValueError("At least one dataset must be selected for prediction.")
         if input_image_ids:
             input_args["image_ids"] = input_image_ids
         elif input_dataset_ids:
             input_args["dataset_ids"] = input_dataset_ids
-        else:
+        elif input_project_id:
             input_args["project_id"] = input_project_id
+        else:
+            raise ValueError("No valid input parameters found for prediction.")
 
         # Settings
         settings = run_parameters["settings"]
         prediction_mode = settings.pop("predictions_mode")
         upload_mode = None
         with_annotations = None
-        if prediction_mode == AddPredictionsMode.REPLACE_EXISTING_LABELS:
+        if prediction_mode == AddPredictionsMode.REPLACE:
             upload_mode = "replace"
             with_annotations = False
-        elif prediction_mode == AddPredictionsMode.MERGE_WITH_EXISTING_LABELS:
+        elif prediction_mode == AddPredictionsMode.APPEND:
             upload_mode = "append"
             with_annotations = True
+        elif prediction_mode == AddPredictionsMode.IOU_MERGE:
+            upload_mode = "iou_merge"
+            with_annotations = True
         elif prediction_mode == AddPredictionsMode.REPLACE_EXISTING_LABELS_AND_SAVE_IMAGE_TAGS:
             upload_mode = "replace"
             with_annotations = True
-        kwargs.update(settings)
-        kwargs["upload_mode"] = upload_mode
+        predict_kwargs.update(settings)
+        predict_kwargs["upload_mode"] = upload_mode
 
         # Classes
         classes = run_parameters["classes"]
         if classes:
-            kwargs["classes"] = classes
+            predict_kwargs["classes"] = classes
 
         # Output
-        # Always create new project
-        # But the actual inference will happen inplace
         output_parameters = run_parameters["output"]
-        project_name = output_parameters.get("project_name", "")
+        project_name = output_parameters.get("project_name", None)
         upload_to_source_project = output_parameters.get("upload_to_source_project", False)
-        if upload_to_source_project:
-            output_project_id = input_project_id
-        else:
-            if not project_name:
-                input_project_info = self.api.project.get_info_by_id(input_project_id)
-                project_name = input_project_info.name + " [Predictions]"
-                logger.warning("Project name is empty, using auto-generated name: " + project_name)
-
-            # Copy project
-            self.set_validator_text("Copying project...", "info")
-            created_project = copy_project(
-                self.api,
-                project_name,
-                self.workspace_id,
-                input_project_id,
-                input_dataset_ids,
-                with_annotations,
-                self.output_selector.progress,
+        skip_project_versioning = output_parameters.get("skip_project_versioning", False)
+        skip_annotated = output_parameters.get("skip_annotated", False)
+
+        image_infos = []
+        if input_image_ids:
+            image_infos = self.api.image.get_info_by_id_batch(input_image_ids)
+        elif input_dataset_ids:
+            for dataset_id in input_dataset_ids:
+                image_infos.extend(self.api.image.get_list(dataset_id))
+        elif input_project_id:
+            datasets = self.api.dataset.get_list(input_project_id, recursive=True)
+            for dataset in datasets:
+                image_infos.extend(self.api.image.get_list(dataset.id))
+        if len(image_infos) == 0:
+            raise ValueError("No images found for the given input parameters.")
+
+        to_skip = []
+        if skip_annotated:
+            to_skip = [image_info.id for image_info in image_infos if image_info.labels_count == 0]
+        if to_skip:
+            image_infos = [info for info in image_infos if info.id not in to_skip]
+        if len(image_infos) == 0:
+            self.set_validator_text(
+                f"All images are already annotated. Nothing to predict.", "warning"
+            )
+            return []
+
+        image_infos_by_project_id: Dict[int, List[ImageInfo]] = {}
+        image_infos_by_dataset_id: Dict[int, List[ImageInfo]] = {}
+        ds_project_mapping: Dict[int, int] = {}
+        for info in image_infos:
+            image_infos_by_dataset_id.setdefault(info.dataset_id, []).append(info)
+            if info.dataset_id not in ds_project_mapping:
+                ds_info = self.api.dataset.get_info_by_id(info.dataset_id)
+                ds_project_mapping[info.dataset_id] = ds_info.project_id
+            project_id = ds_project_mapping[info.dataset_id]
+            image_infos_by_project_id.setdefault(project_id, []).append(info)
+
+        src_project_metas: Dict[int, ProjectMeta] = {}
+        for project_id in image_infos_by_project_id.keys():
+            src_project_metas[project_id] = ProjectMeta.from_json(
+                self.api.project.get_meta(project_id)
             )
-            output_project_id = created_project.id
-            input_args = {
-                "project_id": output_project_id,
-            }
 
-        # ------------------------ #
+        self.output_selector.progress.show()
+        total_items = sum(len(v) for v in image_infos_by_project_id.values())
+        main_pbar = self.output_selector.progress(message=f"Copying images...", total=total_items)
+        for src_project_id, infos in image_infos_by_project_id.items():
+            if len(infos) == 0:
+                continue
+            project_info = self.api.project.get_info_by_id(src_project_id)
+            project_validator_text_str = (
+                f"Processing project: {project_info.name} [id: {src_project_id}]"
+            )
+            if upload_to_source_project:
+                if not skip_project_versioning and not is_development():
+                    logger.info("Creating new project version...")
+                    self.set_validator_text(
+                        project_validator_text_str + ": Creating project version", "info"
+                    )
+                    version_id = self.api.project.version.create(
+                        project_info,
+                        "Created by Predict App. Task Id: " + str(env.task_id()),
+                    )
+                    logger.info("New project version created: " + str(version_id))
+                output_project_id = src_project_id
+                output_image_infos: List[ImageInfo] = infos
+            else:
+                self.set_validator_text(
+                    project_validator_text_str + ": Creating project...", "info"
+                )
+                if not project_name:
+                    project_name = project_info.name + " [Predictions]"
+                    logger.warning(
+                        "Project name is empty, using auto-generated name: " + project_name
+                    )
+                created_project = create_project(
+                    api=self.api,
+                    project_id=src_project_id,
+                    project_name=project_name,
+                    workspace_id=self.workspace_id,
+                    copy_meta=with_annotations,
+                    project_type=ProjectType.IMAGES,
+                )
+                output_project_id = created_project.id
+                output_image_infos: List[ImageInfo] = copy_items_to_project(
+                    api=self.api,
+                    src_project_id=src_project_id,
+                    items=infos,
+                    dst_project_id=created_project.id,
+                    with_annotations=with_annotations,
+                    ds_progress=self.output_selector.secondary_progress,
+                    progress_cb=main_pbar.update,
+                    project_type=ProjectType.IMAGES,
+                )
 
         # Run prediction
         self.set_validator_text("Running prediction...", "info")
-        predictions = []
+        predictions: List[Prediction] = []
         self._is_running = True
+        with self.model_api.predict_detached(
+            image_ids=[info.id for info in output_image_infos],
+            **predict_kwargs,
+            tqdm=self.output_selector.progress(),
+        ) as session:
+            for prediction in session:
+                if self._stop_flag:
+                    logger.info("Prediction stopped by user.")
+                    raise StopIteration("Stopped by user.")
+                predictions.append(prediction)
+        self.set_validator_text("Project successfully processed", "success")
+        self.output_selector.set_result_thumbnail(output_project_id)
+        return predictions
+
+    def run(self, run_parameters: Dict[str, Any] = None) -> List[Prediction]:
+        self.show_validator_text()
+        if run_parameters is None:
+            run_parameters = self.get_run_parameters()
+        input_parameters = run_parameters["input"]
+        video_ids = input_parameters.get("video_ids", None)
         try:
-            with model_api.predict_detached(
-                **input_args,
-                tqdm=self.output_selector.progress(),
-                **kwargs,
-            ) as session:
-                self.output_selector.progress.show()
-                i = 0
-                for prediction in session:
-                    predictions.append(prediction)
-                    i += 1
-                    if self._stop_flag:
-                        logger.info("Prediction stopped by user.")
-                        break
-            self.output_selector.progress.hide()
+            if video_ids:
+                run_f = self._run_videos
+            else:
+                run_f = self._run_images
+            return run_f(run_parameters)
+        except StopIteration:
+            logger.info("Prediction stopped by user.")
+            self.set_validator_text("Prediction stopped by user.", "warning")
+            raise
         except Exception as e:
-            self.output_selector.progress.hide()
             logger.error(f"Error during prediction: {str(e)}")
             self.set_validator_text(f"Error during prediction: {str(e)}", "error")
             disable_enable(self.output_selector.widgets_to_disable, False)
-            self._is_running = False
-            self._stop_flag = False
-            raise e
+            raise
         finally:
+            self.output_selector.secondary_progress.hide()
+            self.output_selector.progress.hide()
             self._is_running = False
             self._stop_flag = False
-        # ------------------------ #
-
-        # Set result thumbnail
-        self.set_validator_text("Project successfully processed", "success")
-        self.output_selector.set_result_thumbnail(output_project_id)
-        # ------------------------ #
-        return predictions
 
     def stop(self):
         logger.info("Stopping prediction...")
@@ -707,14 +899,10 @@ class PredictAppGui:
         if self.tags_selector is not None:
             self.tags_selector.load_from_json(data.get("tags", {}))
 
-        # 5. Settings selector
+        # 5. Settings selector & Preview
         self.settings_selector.load_from_json(data.get("settings", {}))
 
-        # 6. Preview (No need?)
-        if self.preview is not None:
-            self.preview.load_from_json(data.get("preview", {}))
-
-        # 7. Output selector
+        # 6. Output selector
         self.output_selector.load_from_json(data.get("output", {}))
 
     def set_validator_text(self, text: str, status: str = "text"):