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

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

@@ -0,0 +1,110 @@
+from typing import Any, Dict
+from supervisely.app.widgets import Button, Card, Container, TagsTable, Text
+
+
+class TagsSelector:
+    title = "Tags Selector"
+    description = "Select tags that will be used for inference"
+    lock_message = "Select previous step to unlock"
+
+    def __init__(self):
+        # Init Step
+        self.display_widgets = []
+        # -------------------------------- #
+
+        # Init Base Widgets
+        self.validator_text = None
+        self.button = None
+        self.container = None
+        self.card = None
+        # -------------------------------- #
+
+        # Init Step Widgets
+        self.tags_table = None
+        # -------------------------------- #
+
+        # Tags
+        self.tags_table = TagsTable()
+        self.tags_table.hide()
+        # Add widgets to display ------------ #
+        self.display_widgets.extend([self.tags_table])
+        # ----------------------------------- #
+
+        # Base Widgets
+        self.validator_text = Text("")
+        self.validator_text.hide()
+        self.button = Button("Select")
+        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.tags_table]
+
+    def load_from_json(self, data: Dict[str, Any]) -> None:
+        if "tags" in data:
+            self.set_tags(data["tags"])
+
+    def get_selected_tags(self) -> list:
+        return self.tags_table.get_selected_tags()
+
+    def set_tags(self, tags) -> None:
+        self.tags_table.select_tags(tags)
+
+    def select_all_tags(self) -> None:
+        self.tags_table.select_all()
+
+    def get_settings(self) -> Dict[str, Any]:
+        return {"tags": self.get_selected_tags()}
+
+    def validate_step(self) -> bool:
+        if self.tags_table.is_hidden():
+            return True
+
+        self.validator_text.hide()
+
+        project_tags = self.tags_table.project_meta.tag_metas
+        if len(project_tags) == 0:
+            self.validator_text.set(text="Project has no tags", status="error")
+            self.validator_text.show()
+            return False
+
+        selected_tags = self.tags_table.get_selected_tags()
+        table_data = self.tags_table._table_data
+        empty_tags = [
+            row[0]["data"]
+            for row in table_data
+            if row[0]["data"] in selected_tags and row[2]["data"] == 0 and row[3]["data"] == 0
+        ]
+
+        n_tags = len(selected_tags)
+        if n_tags == 0:
+            message = "Please select at least one tag"
+            status = "error"
+        else:
+            tag_text = "tag" if n_tags == 1 else "tags"
+            message = f"Selected {n_tags} {tag_text}"
+            status = "success"
+            if empty_tags:
+                intersections = set(selected_tags).intersection(empty_tags)
+                if intersections:
+                    tag_text = "tag" if len(intersections) == 1 else "tags"
+                    message += (
+                        f". Selected {tag_text} have no annotations: {', '.join(intersections)}"
+                    )
+                    status = "warning"
+
+        self.validator_text.set(text=message, status=status)
+        self.validator_text.show()
+        return n_tags > 0

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

@@ -0,0 +1,282 @@
+from typing import Any, Callable, Dict, List, Optional, Tuple, Set
+from supervisely import logger
+from supervisely.api.api import Api
+from supervisely.api.project_api import ProjectInfo
+from supervisely.api.dataset_api import DatasetInfo
+from supervisely.project.project import ProjectType
+from supervisely.app.widgets import Progress
+from supervisely.app import DataJson
+from supervisely.app.widgets import Button, Card, Stepper, Text, Widget
+
+button_clicked = {}
+
+
+def update_custom_params(
+    button: Button,
+    params_dct: Dict[str, Any],
+) -> None:
+    button_state = button.get_json_data()
+    for key in params_dct.keys():
+        if key not in button_state:
+            raise AttributeError(f"Parameter {key} doesn't exists.")
+        else:
+            DataJson()[button.widget_id][key] = params_dct[key]
+    DataJson().send_changes()
+
+
+def update_custom_button_params(
+    button: Button,
+    params_dct: Dict[str, Any],
+) -> None:
+    params = params_dct.copy()
+    if "icon" in params and params["icon"] is not None:
+        new_icon = f'<i class="{params["icon"]}" style="margin-right: {button._icon_gap}px"></i>'
+        params["icon"] = new_icon
+    update_custom_params(button, params)
+
+
+def disable_enable(widgets: List[Widget], disable: bool = True):
+    for w in widgets:
+        if disable:
+            w.disable()
+        else:
+            w.enable()
+
+
+def unlock_lock(cards: List[Card], unlock: bool = True, message: str = None):
+    for w in cards:
+        if unlock:
+            w.unlock()
+            # w.uncollapse()
+        else:
+            w.lock(message)
+            # w.collapse()
+
+
+def collapse_uncollapse(cards: List[Card], collapse: bool = True):
+    for w in cards:
+        if collapse:
+            w.collapse()
+        else:
+            w.uncollapse()
+
+
+def wrap_button_click(
+    button: Button,
+    cards_to_unlock: List[Card],
+    widgets_to_disable: List[Widget],
+    callback: Optional[Callable] = None,
+    lock_msg: str = None,
+    upd_params: bool = True,
+    validation_text: Text = None,
+    validation_func: Optional[Callable] = None,
+    on_select_click: Optional[Callable] = None,
+    on_reselect_click: Optional[Callable] = None,
+    collapse_card: Tuple[Card, bool] = None,
+) -> Callable[[Optional[bool]], None]:
+    global button_clicked
+
+    select_params = {"icon": None, "plain": False, "text": "Select"}
+    reselect_params = {"icon": "zmdi zmdi-refresh", "plain": True, "text": "Reselect"}
+    bid = button.widget_id
+    button_clicked[bid] = False
+
+    def button_click(button_clicked_value: Optional[bool] = None):
+        if button_clicked_value is None or button_clicked_value is False:
+            if validation_func is not None:
+                success = validation_func()
+                if not success:
+                    return
+
+        if button_clicked_value is not None:
+            button_clicked[bid] = button_clicked_value
+        else:
+            button_clicked[bid] = not button_clicked[bid]
+
+        if button_clicked[bid] and upd_params:
+            update_custom_button_params(button, reselect_params)
+            if on_select_click is not None:
+                for func in on_select_click:
+                    func()
+        else:
+            update_custom_button_params(button, select_params)
+            if on_reselect_click is not None:
+                for func in on_reselect_click:
+                    func()
+            validation_text.hide()
+
+        unlock_lock(
+            cards_to_unlock,
+            unlock=button_clicked[bid],
+            message=lock_msg,
+        )
+        disable_enable(
+            widgets_to_disable,
+            disable=button_clicked[bid],
+        )
+        if callback is not None and not button_clicked[bid]:
+            callback(False)
+
+        if collapse_card is not None:
+            card, collapse = collapse_card
+            if collapse:
+                collapse_uncollapse([card], collapse)
+
+    return button_click
+
+
+def set_stepper_step(stepper: Stepper, button: Button, next_pos: int):
+    bid = button.widget_id
+    if button_clicked[bid] is True:
+        stepper.set_active_step(next_pos)
+    else:
+        stepper.set_active_step(next_pos - 1)
+
+
+def find_parents_in_tree(
+    tree: Dict[DatasetInfo, Dict], dataset_id: int, with_self: bool = False
+) -> Optional[List[DatasetInfo]]:
+    """
+    Find all parent datasets in the tree for a given dataset ID.
+    """
+
+    def _dfs(subtree: Dict[DatasetInfo, Dict], parents: List[DatasetInfo]):
+        for dataset_info, children in subtree.items():
+            if dataset_info.id == dataset_id:
+                if with_self:
+                    return parents + [dataset_info]
+                return parents
+            res = _dfs(children, parents + [dataset_info])
+            if res is not None:
+                return res
+        return None
+
+    return _dfs(tree, [])
+
+
+def copy_project(
+    api: Api,
+    project_name: str,
+    workspace_id: int,
+    project_id: int,
+    dataset_ids: List[int] = [],
+    with_annotations: bool = True,
+    progress: Progress = None,
+):
+    """
+    Copy a project
+
+    :param api: Supervisely API
+    :type api: Api
+    :param project_name: Name of the new project
+    :type project_name: str
+    :param workspace_id: ID of the workspace
+    :type workspace_id: int
+    :param project_id: ID of the project to copy
+    :type project_id: int
+    :param dataset_ids: List of dataset IDs to copy. If empty, all datasets from the project will be copied.
+    :type dataset_ids: List[int]
+    :param with_annotations: Whether to copy annotations
+    :type with_annotations: bool
+    :param progress: Progress callback
+    :type progress: Progress
+    :return: Created project
+    :rtype: ProjectInfo
+    """
+
+    def _create_project() -> ProjectInfo:
+        created_project = api.project.create(
+            workspace_id,
+            project_name,
+            type=ProjectType.IMAGES,
+            change_name_if_conflict=True,
+        )
+        if with_annotations:
+            api.project.merge_metas(src_project_id=project_id, dst_project_id=created_project.id)
+        return created_project
+
+    def _copy_full_project(
+        created_project: ProjectInfo, src_datasets_tree: Dict[DatasetInfo, Dict]
+    ):
+        src_dst_ds_id_map: Dict[int, int] = {}
+
+        def _create_full_tree(ds_tree: Dict[DatasetInfo, Dict], parent_id: int = None):
+            for src_ds, nested_src_ds_tree in ds_tree.items():
+                dst_ds = api.dataset.create(
+                    project_id=created_project.id,
+                    name=src_ds.name,
+                    description=src_ds.description,
+                    change_name_if_conflict=True,
+                    parent_id=parent_id,
+                )
+                src_dst_ds_id_map[src_ds.id] = dst_ds
+
+                # Preserve dataset custom data
+                info_ds = api.dataset.get_info_by_id(src_ds.id)
+                if info_ds.custom_data:
+                    api.dataset.update_custom_data(dst_ds.id, info_ds.custom_data)
+                _create_full_tree(nested_src_ds_tree, parent_id=dst_ds.id)
+
+        _create_full_tree(src_datasets_tree)
+
+        for src_ds_id, dst_ds in src_dst_ds_id_map.items():
+            _copy_items(src_ds_id, dst_ds)
+
+    def _copy_datasets(created_project: ProjectInfo, src_datasets_tree: Dict[DatasetInfo, Dict]):
+        created_datasets: Dict[int, DatasetInfo] = {}
+        processed_copy: Set[int] = set()
+
+        for dataset_id in dataset_ids:
+            chain = find_parents_in_tree(src_datasets_tree, dataset_id, with_self=True)
+            if not chain:
+                logger.warning(
+                    f"Dataset id {dataset_id} not found in project {project_id}. Skipping."
+                )
+                continue
+
+            parent_created_id = None
+            for ds_info in chain:
+                if ds_info.id in created_datasets:
+                    parent_created_id = created_datasets[ds_info.id].id
+                    continue
+
+                created_ds = api.dataset.create(
+                    created_project.id,
+                    ds_info.name,
+                    description=ds_info.description,
+                    change_name_if_conflict=False,
+                    parent_id=parent_created_id,
+                )
+                created_datasets[ds_info.id] = created_ds
+                src_info = api.dataset.get_info_by_id(ds_info.id)
+                if src_info.custom_data:
+                    api.dataset.update_custom_data(created_ds.id, src_info.custom_data)
+                parent_created_id = created_ds.id
+
+            if dataset_id not in processed_copy:
+                _copy_items(dataset_id, created_datasets[dataset_id])
+                processed_copy.add(dataset_id)
+
+    def _copy_items(src_ds_id: int, dst_ds: DatasetInfo):
+        input_img_infos = api.image.get_list(src_ds_id)
+        with progress(
+            message=f"Copying items from dataset: {dst_ds.name}", total=len(input_img_infos)
+        ) as pbar:
+            progress.show()
+            api.image.copy_batch_optimized(
+                src_dataset_id=src_ds_id,
+                src_image_infos=input_img_infos,
+                dst_dataset_id=dst_ds.id,
+                with_annotations=with_annotations,
+                progress_cb=pbar.update,
+            )
+            progress.hide()
+
+    created_project = _create_project()
+    src_datasets_tree = api.dataset.get_tree(project_id)
+
+    if not dataset_ids:
+        _copy_full_project(created_project, src_datasets_tree)
+    else:
+        _copy_datasets(created_project, src_datasets_tree)
+    return created_project

supervisely/nn/inference/predict_app/predict_app.py

@@ -0,0 +1,184 @@
+import os
+from typing import Dict, List, Optional
+
+from fastapi import BackgroundTasks, Request
+
+from supervisely._utils import logger
+from supervisely.api.api import Api
+from supervisely.app.fastapi.subapp import Application
+from supervisely.nn.inference.predict_app.gui.gui import PredictAppGui
+from supervisely.nn.model.prediction import Prediction
+from supervisely.nn.inference.predict_app.gui.utils import disable_enable
+import supervisely.io.fs as sly_fs
+
+
+class PredictApp:
+    def __init__(self, api: Api):
+        _static_dir = "static"
+        sly_fs.mkdir(_static_dir, True)
+        self.api = api
+        self.gui = PredictAppGui(api, static_dir=_static_dir)
+        self.app = Application(self.gui.layout, static_dir=_static_dir)
+        self._add_endpoints()
+
+        @self.gui.output_selector.start_button.click
+        def start_prediction():
+            if self.gui.output_selector.validate_step():
+                disable_enable(self.gui.output_selector.widgets_to_disable, True)
+                self.gui.run()
+                self.shutdown_serving_app()
+                self.shutdown_predict_app()
+
+    def shutdown_serving_app(self):
+        if self.gui.output_selector.should_stop_serving_on_finish():
+            logger.info("Stopping serving app...")
+            self.gui.model_selector.model.stop()
+
+    def shutdown_predict_app(self):
+        if self.gui.output_selector.should_stop_self_on_finish():
+            self.gui.output_selector.start_button.disable()
+            logger.info("Stopping Predict App...")
+            self.app.stop()
+        else:
+            disable_enable(self.gui.output_selector.widgets_to_disable, False)
+            self.gui.output_selector.start_button.enable()
+
+    def run(self, run_parameters: Optional[Dict] = None) -> List[Prediction]:
+        return self.gui.run(run_parameters)
+
+    def stop(self):
+        self.gui.stop()
+
+    def shutdown_model(self):
+        self.gui.shutdown_model()
+
+    def load_from_json(self, data):
+        self.gui.load_from_json(data)
+        if data.get("run", False):
+            try:
+                self.run()
+            except Exception as e:
+                raise
+            finally:
+                if data.get("stop_after_run", False):
+                    self.shutdown_model()
+                    self.app.stop()
+
+    def get_inference_settings(self):
+        return self.gui.settings_selector.get_inference_settings()
+
+    def get_run_parameters(self):
+        return self.gui.get_run_parameters()
+
+    def _add_endpoints(self):
+        server = self.app.get_server()
+
+        @server.post("/load")
+        def load(request: Request, background_tasks: BackgroundTasks):
+            """
+            Load the model state from a JSON object.
+            This endpoint initializes the model with the provided state.
+            All the fields are optional
+
+            Example state:
+                state = {
+                    "model": {
+                        "mode": "connect",
+                        "session_id": "12345"
+                        # "mode": "pretrained",
+                        # "framework: "YOLO",
+                        # "model_name": "YOLO11m-seg",
+                        # "mode": "custom",
+                        # "train_task_id": 123
+                    },
+                    "items": {
+                        "project_id": 123,
+                        # "dataset_ids": [...],
+                        # "video_id": 123
+                    },
+                    "inference_settings": {
+                        "confidence_threshold": 0.5
+                    },
+                    "output": {
+                        "mode": "create",
+                        "project_name": "Predictions",
+                        # "mode": "append",
+                        # "mode": "replace",
+                        # "mode": "iou_merge",
+                        # "iou_merge_threshold": 0.5
+                    }
+                }
+            """
+            state = request.state.state
+            stop_after_run = state.get("stop_after_run", False)
+            if stop_after_run:
+                state["stop_after_run"] = False
+            self.load_from_json(state)
+            if stop_after_run:
+                self.shutdown_model()
+                background_tasks.add_task(self.app.stop)
+
+        @server.post("/deploy")
+        def deploy(request: Request):
+            """
+            Deploy the model for inference.
+            This endpoint prepares the model for running predictions.
+            """
+            self.gui.model_selector.model._deploy()
+
+        @server.get("/inference_settings")
+        def get_inference_settings():
+            """
+            Get the inference settings for the model.
+            This endpoint returns the current inference settings.
+            """
+            return self.get_inference_settings()
+
+        @server.get("/run_parameters")
+        def get_run_parameters():
+            """
+            Get the run parameters for the model.
+            This endpoint returns the parameters needed to run the model.
+            """
+            return self.get_run_parameters()
+
+        @server.post("/predict")
+        def predict(request: Request):
+            """
+            Run the model prediction.
+            This endpoint processes the request data and runs the model prediction.
+
+            Example data:
+                data = {
+                    "inference_settings": {
+                        "conf": 0.6,
+                    },
+                    "item": {
+                        # "project_id": ...,
+                        # "dataset_ids": [...],
+                        "image_ids": [1148679, 1148675],
+                    },
+                    "output": {"mode": "iou_merge", "iou_merge_threshold": 0.5},
+                }
+            """
+            state = request.state.state
+            run_parameters = {
+                "item": state["item"],
+            }
+            if "inference_settings" in state:
+                run_parameters["inference_settings"] = state["inference_settings"]
+            if "output" in state:
+                run_parameters["output"] = state["output"]
+            else:
+                run_parameters["output"] = {"mode": None}
+
+            predictions = self.run(run_parameters)
+            return [prediction.to_json() for prediction in predictions]
+
+        @server.post("/run")
+        def run(request: Request):
+            """
+            Run the model prediction.
+            """
+            predicitons = self.run()
+            return [prediction.to_json() for prediction in predicitons]

supervisely/nn/inference/uploader.py

@@ -105,10 +105,6 @@ class Uploader:
             self.stop()
             return
         except Exception as e:
-            try:
-                raise RuntimeError("Error in upload loop") from e
-            except RuntimeError as e_:
-                e = e_
             if self._logger is not None:
                 self._logger.error("Error in upload loop: %s", str(e), exc_info=True)
             if not self._exception_event.is_set():
@@ -152,7 +148,9 @@ class Uploader:
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.stop()
         try:
-            self.join(timeout=5)
+            self.join(timeout=30)
+            if self._upload_thread.is_alive():
+                raise TimeoutError("Uploader thread didn't finish in time")
         except TimeoutError:
             _logger = logger
             if self._logger is not None:
@@ -161,4 +159,10 @@ class Uploader:
         if exc_type is not None:
             exc = exc_val.with_traceback(exc_tb)
             return self._exception_handler(exc)
+        if self.has_exception():
+            exc = self.exception
+            try:
+                raise RuntimeError(f"Error in uploader loop: {str(exc)}") from exc
+            except Exception as exc:
+                return self._exception_handler(exc)
         return False

supervisely/nn/model/prediction.py

@@ -240,6 +240,8 @@ class Prediction:
             if self.image_id is not None:
                 try:
                     if api is None:
+                        # TODO: raise more clarifying error in case of failing of api init
+                        # what a user should do to fix it?
                         api = Api()
                     return api.image.download_np(self.image_id)
                 except Exception as e:

supervisely/nn/model/prediction_session.py

@@ -132,6 +132,14 @@ class PredictionSession:
             self.tracker = None
             self.tracker_settings = None
 
+        if "classes" in kwargs:
+            self.inference_settings["classes"] = kwargs["classes"]
+        # TODO: remove "settings", it is the same as inference_settings
+        if "settings" in kwargs:
+            self.inference_settings.update(kwargs["settings"])
+        if "inference_settings" in kwargs:
+            self.inference_settings.update(kwargs["inference_settings"])
+
         # extra input args
         image_ids = self._set_var_from_kwargs("image_ids", kwargs, image_id)
         video_ids = self._set_var_from_kwargs("video_ids", kwargs, video_id)
@@ -159,7 +167,6 @@ class PredictionSession:
             input = [input]
         if isinstance(input[0], np.ndarray):
             # input is numpy array
-            kwargs = get_valid_kwargs(kwargs, self._predict_images, exclude=["images"])
             self._predict_images(input, **kwargs)
         elif isinstance(input[0], (str, PathLike)):
             if len(input) > 1:
@@ -288,6 +295,8 @@ class PredictionSession:
             body["state"]["settings"] = self.inference_settings
         if self.api_token is not None:
             body["api_token"] = self.api_token
+        if "model_prediction_suffix" in self.kwargs:
+            body["state"]["model_prediction_suffix"] = self.kwargs["model_prediction_suffix"]
         return body
     
     def _post(self, method, *args, retries=5, **kwargs) -> requests.Response:
@@ -562,7 +571,11 @@ class PredictionSession:
         return self._predict_images_bytes(images, batch_size=batch_size)
 
     def _predict_images_ids(
-        self, images: List[int], batch_size: int = None, upload_mode: str = None
+        self,
+        images: List[int],
+        batch_size: int = None,
+        upload_mode: str = None,
+        output_project_id: int = None,
     ):
         method = "inference_batch_ids_async"
         json_body = self._get_json_body()
@@ -572,6 +585,8 @@ class PredictionSession:
             state["batch_size"] = batch_size
         if upload_mode is not None:
             state["upload_mode"] = upload_mode
+        if output_project_id is not None:
+            state["output_project_id"] = output_project_id
         return self._start_inference(method, json=json_body)
 
     def _predict_videos(
@@ -647,6 +662,7 @@ class PredictionSession:
         upload_mode: str = None,
         iou_merge_threshold: float = None,
         cache_project_on_model: bool = None,
+        output_project_id: int = None,
     ):
         if len(project_ids) != 1:
             raise ValueError("Only one project can be processed at a time.")
@@ -664,7 +680,8 @@ class PredictionSession:
             state["iou_merge_threshold"] = iou_merge_threshold
         if cache_project_on_model is not None:
             state["cache_project_on_model"] = cache_project_on_model
-
+        if output_project_id is not None:
+            state["output_project_id"] = output_project_id
         return self._start_inference(method, json=json_body)
 
     def _predict_datasets(