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

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

@@ -1,4 +1,5 @@
 from typing import Any, Dict
+
 from supervisely.app.widgets import Button, Card, Container, TagsTable, Text
 
 
@@ -45,7 +46,6 @@ class TagsSelector:
             content=self.container,
             lock_message=self.lock_message,
         )
-        self.card.lock()
         # -------------------------------- #
 
     @property

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

@@ -1,12 +1,22 @@
-from typing import Any, Callable, Dict, List, Optional, Tuple, Set
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+
 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.api.image_api import ImageInfo
+from supervisely.api.project_api import ProjectInfo
 from supervisely.app import DataJson
-from supervisely.app.widgets import Button, Card, Stepper, Text, Widget
+from supervisely.app.widgets import Button, Card, Progress, Stepper, Text, Widget
+from supervisely.nn.model.prediction import Prediction
+from supervisely.project.project import ProjectType
+from supervisely.project.project_meta import ProjectMeta
+from supervisely.project.video_project import VideoInfo
+from supervisely.video_annotation.frame import Frame
+from supervisely.video_annotation.frame_collection import FrameCollection
+from supervisely.video_annotation.video_annotation import VideoAnnotation
+from supervisely.video_annotation.video_figure import VideoFigure
+from supervisely.video_annotation.video_object import VideoObject
+from supervisely.video_annotation.video_object_collection import VideoObjectCollection
 
 button_clicked = {}
 
@@ -81,7 +91,7 @@ def wrap_button_click(
     bid = button.widget_id
     button_clicked[bid] = False
 
-    def button_click(button_clicked_value: Optional[bool] = None):
+    def button_click(button_clicked_value: Optional[bool] = None, suppress_actions: bool = False):
         if button_clicked_value is None or button_clicked_value is False:
             if validation_func is not None:
                 success = validation_func()
@@ -95,12 +105,12 @@ def wrap_button_click(
 
         if button_clicked[bid] and upd_params:
             update_custom_button_params(button, reselect_params)
-            if on_select_click is not None:
+            if not suppress_actions and 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:
+            if not suppress_actions and on_reselect_click is not None:
                 for func in on_reselect_click:
                     func()
             validation_text.hide()
@@ -115,7 +125,7 @@ def wrap_button_click(
             disable=button_clicked[bid],
         )
         if callback is not None and not button_clicked[bid]:
-            callback(False)
+            callback(False, True)
 
         if collapse_card is not None:
             card, collapse = collapse_card
@@ -154,129 +164,236 @@ def find_parents_in_tree(
     return _dfs(tree, [])
 
 
-def copy_project(
+def _copy_items_to_dataset(
     api: Api,
-    project_name: str,
-    workspace_id: int,
-    project_id: int,
-    dataset_ids: List[int] = [],
+    src_dataset_id: int,
+    dst_dataset: DatasetInfo,
+    project_type: str,
     with_annotations: bool = True,
+    progress_cb: Callable = None,
     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
-    """
+    items_infos: List[Union[ImageInfo, VideoInfo]] = None,
+) -> Union[List[ImageInfo], List[VideoInfo]]:
+    if progress is None:
+        progress = Progress()
+
+    def combined_progress(n):
+        progress_cb(n)
+        pbar.update(n)
+
+    if project_type == ProjectType.IMAGES:
+        if items_infos is None:
+            items_infos = api.image.get_list(src_dataset_id)
+        with progress(
+            message=f"Copying items from dataset: {dst_dataset.name}", total=len(items_infos)
+        ) as pbar:
 
-    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
+            if progress_cb:
+                _progress_cb = combined_progress
+            else:
+                _progress_cb = pbar.update
 
-            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
+            progress.show()
+            copied = api.image.copy_batch_optimized(
+                src_dataset_id=src_dataset_id,
+                src_image_infos=items_infos,
+                dst_dataset_id=dst_dataset.id,
+                with_annotations=with_annotations,
+                progress_cb=_progress_cb,
+            )
+            progress.hide()
+    elif project_type == ProjectType.VIDEOS:
+        if items_infos is None:
+            items_infos = api.video.get_list(src_dataset_id)
 
-                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)
+            message=f"Copying items from dataset: {dst_dataset.name}", total=len(items_infos)
         ) as pbar:
+            if progress_cb:
+                _progress_cb = combined_progress
+            else:
+                _progress_cb = pbar.update
             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,
+            copied = api.video.copy_batch(
+                dst_dataset_id=dst_dataset.id,
+                ids=[info.id for info in items_infos],
                 with_annotations=with_annotations,
-                progress_cb=pbar.update,
+                progress_cb=_progress_cb,
             )
             progress.hide()
+    else:
+        raise NotImplementedError(f"Copy not implemented for project type {project_type}")
+    return copied
 
-    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)
+def get_items_infos(
+    api: Api, items_ids: List[int], project_type: str
+) -> List[Union[ImageInfo, VideoInfo]]:
+    if project_type == ProjectType.IMAGES:
+        items_infos: List[ImageInfo] = api.image.get_info_by_id_batch(items_ids)
+    elif project_type == ProjectType.VIDEOS:
+        items_infos: List[VideoInfo] = api.video.get_info_by_id_batch(items_ids)
     else:
-        _copy_datasets(created_project, src_datasets_tree)
+        raise NotImplementedError(f"Items of type {project_type} are not supported")
+    return items_infos
+
+
+def copy_items_to_project(
+    api: Api,
+    src_project_id: int,
+    items: Union[List[ImageInfo], List[VideoInfo]],
+    dst_project_id: int,
+    with_annotations: bool = True,
+    progress_cb: Progress = None,
+    ds_progress: Progress = None,
+    project_type: str = None,
+    src_datasets_tree: Dict[DatasetInfo, Dict] = None,
+) -> Union[List[ImageInfo], List[VideoInfo]]:
+    if project_type is None:
+        dst_project_info = api.project.get_info_by_id(src_project_id)
+        project_type = dst_project_info.type
+    if len(items) == 0:
+        return []
+    if len(set(info.project_id for info in items)) != 1:
+        raise ValueError("Items must belong to the same project")
+
+    items_by_dataset: Dict[int, List[Union[ImageInfo, VideoInfo]]] = {}
+    for item_info in items:
+        items_by_dataset.setdefault(item_info.dataset_id, []).append(item_info)
+
+    if src_datasets_tree is None:
+        src_datasets_tree = api.dataset.get_tree(src_project_id)
+
+    created_datasets: Dict[int, DatasetInfo] = {}
+    processed_copy: Set[int] = set()
+
+    copied_items = {}
+    for dataset_id, items_infos in items_by_dataset.items():
+        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. 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(
+                dst_project_id,
+                ds_info.name,
+                description=ds_info.description,
+                change_name_if_conflict=False,
+                parent_id=parent_created_id,
+            )
+            if ds_info.custom_data:
+                created_ds = api.dataset.update_custom_data(created_ds.id, ds_info.custom_data)
+            created_datasets[ds_info.id] = created_ds
+            parent_created_id = created_ds.id
+
+        if dataset_id not in processed_copy:
+            copied_ds_items = _copy_items_to_dataset(
+                api=api,
+                src_dataset_id=dataset_id,
+                dst_dataset=created_datasets[dataset_id],
+                project_type=project_type,
+                with_annotations=with_annotations,
+                progress_cb=progress_cb,
+                progress=ds_progress,
+                items_infos=items_infos,
+            )
+            for src_info, dst_info in zip(items_infos, copied_ds_items):
+                copied_items[src_info.id] = dst_info
+            processed_copy.add(dataset_id)
+    return [copied_items[item.id] for item in items]
+
+
+def create_project(
+    api: Api,
+    project_id: int,
+    project_name: str,
+    workspace_id: int,
+    copy_meta: bool = False,
+    project_type: str = None,
+) -> ProjectInfo:
+    if project_type is None:
+        project_info = api.project.get_info_by_id(project_id)
+        project_type = project_info.type
+    created_project = api.project.create(
+        workspace_id,
+        project_name,
+        type=project_type,
+        change_name_if_conflict=True,
+    )
+    if copy_meta:
+        api.project.merge_metas(src_project_id=project_id, dst_project_id=created_project.id)
     return created_project
+
+
+def copy_project(
+    api: Api,
+    project_id: int,
+    workspace_id: int,
+    project_name: str,
+    items_ids: List[int] = None,
+    with_annotations: bool = True,
+    progress: Progress = None,
+) -> ProjectInfo:
+    dst_project = create_project(
+        api, project_id, project_name, workspace_id=workspace_id, copy_meta=True
+    )
+    items = []
+    if items_ids is None:
+        project_type = dst_project.type
+        datasets = api.dataset.get_list(project_id, recursive=True)
+        if project_type == ProjectType.IMAGES:
+            get_items_f = api.image.get_list
+        elif project_type == ProjectType.VIDEOS:
+            get_items_f = api.video.get_list
+        else:
+            raise NotImplementedError(f"Project type {project_type} is not supported")
+        for ds in datasets:
+            ds_items = get_items_f(dataset_id=ds.id)
+            if ds_items:
+                items.extend(ds_items)
+    else:
+        items = get_items_infos(api, items_ids, dst_project.type)
+    copy_items_to_project(
+        api=api,
+        src_project_id=project_id,
+        items=items,
+        dst_project_id=dst_project.id,
+        with_annotations=with_annotations,
+        ds_progress=progress,
+        project_type=dst_project.type,
+    )
+    return dst_project
+
+
+def video_annotation_from_predictions(
+    predictions: List[Prediction], project_meta: ProjectMeta, frame_size: Tuple[int, int]
+) -> VideoAnnotation:
+    objects = {}
+    frames = []
+    for i, prediction in enumerate(predictions):
+        figures = []
+        for label in prediction.annotation.labels:
+            obj_name = label.obj_class.name
+            if not obj_name in objects:
+                obj_class = project_meta.get_obj_class(obj_name)
+                if obj_class is None:
+                    continue
+                objects[obj_name] = VideoObject(obj_class)
+
+            vid_object = objects[obj_name]
+            if vid_object:
+                figures.append(VideoFigure(vid_object, label.geometry, frame_index=i))
+        frame = Frame(i, figures=figures)
+        frames.append(frame)
+    return VideoAnnotation(
+        img_size=frame_size,
+        frames_count=len(frames),
+        objects=VideoObjectCollection(list(objects.values())),
+        frames=FrameCollection(frames),
+    )

supervisely/nn/inference/predict_app/predict_app.py

@@ -1,4 +1,3 @@
-import os
 from typing import Dict, List, Optional
 
 from fastapi import BackgroundTasks, Request
@@ -24,7 +23,8 @@ class PredictApp:
         @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)
+                widgets_to_disable = self.gui.output_selector.widgets_to_disable + [self.gui.settings_selector.preview.run_button]
+                disable_enable(widgets_to_disable, True)
                 self.gui.run()
                 self.shutdown_serving_app()
                 self.shutdown_predict_app()

supervisely/nn/model/model_api.py

@@ -72,6 +72,15 @@ class ModelAPI:
         else:
             return self._post("get_custom_inference_settings", {})["settings"]
 
+    def get_tracking_settings(self):
+        # @TODO: botsort hardcoded 
+        # Add dropdown selector for tracking algorithms later
+        if self.task_id is not None:
+            return self.api.task.send_request(self.task_id, "get_tracking_settings", {})["botsort"]
+        else:
+            return self._post("get_tracking_settings", {})["botsort"]
+
+
     def get_model_meta(self):
         if self.task_id is not None:
             return ProjectMeta.from_json(

supervisely/nn/tracker/base_tracker.py

@@ -36,9 +36,19 @@ class BaseTracker:
     def video_annotation(self) -> VideoAnnotation:
         """Return the accumulated VideoAnnotation."""
         raise NotImplementedError("This method should be overridden by subclasses.")
+    
+    @classmethod
+    def get_default_params(cls) -> Dict[str, Any]:
+        """
+        Get default configurable parameters for this tracker.
+        Must be implemented in subclass.
+        """
+        raise NotImplementedError(
+            f"Method get_default_params() must be implemented in {cls.__name__}"
+        )
 
     def _validate_device(self) -> None:
         if self.device != 'cpu' and not self.device.startswith('cuda'):
             raise ValueError(
                 f"Invalid device '{self.device}'. Supported devices are 'cpu' or 'cuda'."
-            )
+            )   

supervisely/nn/tracker/botsort/botsort_config.yaml

@@ -1,6 +1,5 @@
 # botsort_default_config.yaml
 
-name: "BotSORT"
 device: "auto" # "cuda" or "cpu", "auto" will use cuda if available
 fp16: false
 

supervisely/nn/tracker/botsort_tracker.py

@@ -54,6 +54,7 @@ class BotSortTracker(BaseTracker):
             self.settings.update(settings)
         
         args = SimpleNamespace(**self.settings)
+        args.name = "BotSORT"
         args.device = self.device
             
         self.tracker = BoTSORT(args=args)
@@ -66,12 +67,8 @@ class BotSortTracker(BaseTracker):
         self.frame_shape = () 
 
     def _load_default_settings(self) -> dict:
-        """Load default settings from YAML file in the same directory."""
-        current_dir = Path(__file__).parent
-        config_path = current_dir / "botsort/botsort_config.yaml"
-        
-        with open(config_path, 'r', encoding='utf-8') as file:
-            return yaml.safe_load(file)
+        """Internal method: calls classmethod"""
+        return self.get_default_params()
 
     def update(self, frame: np.ndarray, annotation: Annotation) -> List[Dict[str, Any]]:
         """Update tracker and return list of matches for current frame."""
@@ -263,4 +260,14 @@ class BotSortTracker(BaseTracker):
             )
             raise ValueError(error_msg)
                 
-        return self._create_video_annotation()
+        return self._create_video_annotation()
+
+    @classmethod
+    def get_default_params(cls) -> Dict[str, Any]:
+        """Public API: get default params WITHOUT creating instance."""
+        current_dir = Path(__file__).parent
+        config_path = current_dir / "botsort/botsort_config.yaml"
+        
+        with open(config_path, 'r', encoding='utf-8') as file:
+            return yaml.safe_load(file)
+