supervisely 6.73.452__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/app/widgets/select_class/select_class.py

@@ -0,0 +1,363 @@
+from typing import Callable, List, Optional, Union
+
+from supervisely import ObjClass, ObjClassCollection
+from supervisely.app import DataJson, StateJson
+from supervisely.app.widgets import Text, Widget
+from supervisely.geometry.alpha_mask import AlphaMask
+from supervisely.geometry.any_geometry import AnyGeometry
+from supervisely.geometry.bitmap import Bitmap
+from supervisely.geometry.closed_surface_mesh import ClosedSurfaceMesh
+from supervisely.geometry.cuboid_2d import Cuboid2d
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.geometry.graph import GraphNodes
+from supervisely.geometry.mask_3d import Mask3D
+from supervisely.geometry.multichannel_bitmap import MultichannelBitmap
+from supervisely.geometry.oriented_bbox import OrientedBBox
+from supervisely.geometry.point import Point
+from supervisely.geometry.point_3d import Point3d
+from supervisely.geometry.pointcloud import Pointcloud
+from supervisely.geometry.polygon import Polygon
+from supervisely.geometry.polyline import Polyline
+from supervisely.geometry.rectangle import Rectangle
+from supervisely.imaging.color import generate_rgb
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+type_to_shape_text = {
+    AnyGeometry: "any shape",
+    Rectangle: "rectangle",
+    Polygon: "polygon",
+    AlphaMask: "alpha mask",
+    Bitmap: "bitmap (mask)",
+    Polyline: "polyline",
+    Point: "point",
+    Cuboid2d: "cuboid 2d",
+    Cuboid3d: "cuboid 3d",
+    Pointcloud: "pointcloud",
+    MultichannelBitmap: "n-channel mask",
+    Point3d: "point 3d",
+    GraphNodes: "keypoints",
+    ClosedSurfaceMesh: "volume (3d mask)",
+    Mask3D: "3d mask",
+    OrientedBBox: "oriented bbox",
+}
+
+shape_text_to_type = {v: k for k, v in type_to_shape_text.items()}
+
+# Geometry types available for creating new classes (excluding GraphNodes)
+available_geometry_types = [
+    {"value": "rectangle", "label": "Rectangle"},
+    {"value": "polygon", "label": "Polygon"},
+    {"value": "bitmap (mask)", "label": "Bitmap (mask)"},
+    {"value": "polyline", "label": "Polyline"},
+    {"value": "point", "label": "Point"},
+    {"value": "any shape", "label": "Any shape"},
+    {"value": "oriented bbox", "label": "Oriented Bounding Box"},
+]
+
+
+class SelectClass(Widget):
+    """
+    SelectClass is a compact dropdown widget for selecting object classes with an option to create
+    new classes on the fly.
+
+    :param classes: Initial list of ObjClass instances
+    :type classes: Optional[Union[List[ObjClass], ObjClassCollection]]
+    :param filterable: Enable search/filter functionality in dropdown
+    :type filterable: Optional[bool]
+    :param placeholder: Placeholder text when no class is selected
+    :type placeholder: Optional[str]
+    :param show_add_new_class: Show "Add new class" option at the end of the list
+    :type show_add_new_class: Optional[bool]
+    :param size: Size of the select dropdown
+    :type size: Optional[Literal["large", "small", "mini"]]
+    :param multiple: Enable multiple selection
+    :type multiple: bool
+    :param widget_id: Unique widget identifier
+    :type widget_id: Optional[str]
+
+    :Usage example:
+
+     .. code-block:: python
+
+        import supervisely as sly
+        from supervisely.app.widgets import SelectClass
+
+        # Create some initial classes
+        class_car = sly.ObjClass('car', sly.Rectangle, color=[255, 0, 0])
+        class_person = sly.ObjClass('person', sly.Polygon, color=[0, 255, 0])
+
+        # Create SelectClass widget
+        select_class = SelectClass(
+            classes=[class_car, class_person],
+            filterable=True,
+            show_add_new_class=True
+        )
+
+        # Handle selection changes
+        @select_class.value_changed
+        def on_class_selected(class_name):
+            print(f"Selected class: {class_name}")
+            selected_class = select_class.get_selected_class()
+            print(f"Class object: {selected_class}")
+
+        # Handle new class creation
+        @select_class.class_created
+        def on_class_created(new_class: sly.ObjClass):
+            print(f"New class created: {new_class.name}")
+            # Optionally update your project meta or perform other actions
+    """
+
+    class Routes:
+        VALUE_CHANGED = "value_changed"
+        CLASS_CREATED = "class_created_cb"
+
+    def __init__(
+        self,
+        classes: Optional[Union[List[ObjClass], ObjClassCollection]] = [],
+        filterable: Optional[bool] = True,
+        placeholder: Optional[str] = "Select class",
+        show_add_new_class: Optional[bool] = True,
+        size: Optional[Literal["large", "small", "mini"]] = None,
+        multiple: bool = False,
+        widget_id: Optional[str] = None,
+    ):
+        # Convert to list for internal use to allow mutations when adding new classes
+        if isinstance(classes, ObjClassCollection):
+            self._classes = list(classes)
+        else:
+            self._classes = list(classes) if classes else []
+
+        self._filterable = filterable
+        self._placeholder = placeholder
+        self._show_add_new_class = show_add_new_class
+        self._size = size
+        self._multiple = multiple
+
+        self._changes_handled = False
+        self._class_created_callback = None
+
+        # Store error message widget
+        self._error_message = Text("", status="error", font_size=13)
+
+        # Initialize parent Widget
+        super().__init__(widget_id=widget_id, file_path=__file__)
+
+        # Register class_created route if show_add_new_class is enabled
+        if self._show_add_new_class:
+            self._register_class_created_route()
+
+    def get_json_data(self):
+        """Build JSON data for the widget."""
+        # Build items list with class info
+        items = []
+        for cls in self._classes:
+            shape_text = type_to_shape_text.get(cls.geometry_type, "")
+            items.append(
+                {
+                    "value": cls.name,
+                    "label": cls.name,
+                    "color": cls.color,
+                    "geometryType": shape_text.upper() if shape_text else "",
+                }
+            )
+
+        return {
+            "items": items,
+            "placeholder": self._placeholder,
+            "filterable": self._filterable,
+            "multiple": self._multiple,
+            "size": self._size,
+            "showAddNewClass": self._show_add_new_class,
+            "availableGeometryTypes": available_geometry_types,
+        }
+
+    def get_json_state(self):
+        """Build JSON state for the widget."""
+        return {
+            "value": self._classes[0].name if self._classes else None,
+            "createClassDialog": {
+                "visible": False,
+                "className": "",
+                "geometryType": "rectangle",
+                "showError": False,
+            },
+        }
+
+    def get_value(self) -> Union[str, List[str], None]:
+        """Get the currently selected class name(s)."""
+        return StateJson()[self.widget_id]["value"]
+
+    def get_selected_class(self) -> Union[ObjClass, List[ObjClass], None]:
+        """Get the currently selected ObjClass object(s)."""
+        value = self.get_value()
+        if value is None:
+            return None
+
+        if self._multiple:
+            if not isinstance(value, list):
+                return []
+            result = []
+            for class_name in value:
+                for cls in self._classes:
+                    if cls.name == class_name:
+                        result.append(cls)
+                        break
+            return result
+        else:
+            for cls in self._classes:
+                if cls.name == value:
+                    return cls
+            return None
+
+    def set_value(self, class_name: Union[str, List[str]]):
+        """Set the selected class by name."""
+        StateJson()[self.widget_id]["value"] = class_name
+        StateJson().send_changes()
+
+    def get_all_classes(self) -> List[ObjClass]:
+        """Get all available classes."""
+        return self._classes.copy()
+
+    def set(self, classes: Union[List[ObjClass], ObjClassCollection]):
+        """Update the list of available classes."""
+        # Convert to list for internal use
+        if isinstance(classes, ObjClassCollection):
+            self._classes = list(classes)
+        else:
+            self._classes = list(classes) if classes else []
+
+        # Update data
+        DataJson()[self.widget_id] = self.get_json_data()
+        DataJson().send_changes()
+
+        # Reset value if current selection is not in new classes
+        current_value = StateJson()[self.widget_id]["value"]
+        if current_value:
+            if self._multiple:
+                if isinstance(current_value, list):
+                    # Keep only valid selections
+                    valid = [
+                        v for v in current_value if any(cls.name == v for cls in self._classes)
+                    ]
+                    if valid != current_value:
+                        StateJson()[self.widget_id]["value"] = valid
+                        StateJson().send_changes()
+            else:
+                if not any(cls.name == current_value for cls in self._classes):
+                    StateJson()[self.widget_id]["value"] = (
+                        self._classes[0].name if self._classes else None
+                    )
+                    StateJson().send_changes()
+
+    def _show_error(self, message: str):
+        """Show error message in the create class dialog."""
+        self._error_message.text = message
+        StateJson()[self.widget_id]["createClassDialog"]["showError"] = True
+        StateJson().send_changes()
+
+    def _hide_dialog(self):
+        """Hide the create class dialog and reset its state."""
+        state_obj = StateJson()[self.widget_id]["createClassDialog"]
+        state_obj["visible"] = False
+        state_obj["className"] = ""
+        state_obj["showError"] = False
+        StateJson().send_changes()
+
+    def _add_new_class(self, new_class: ObjClass):
+        """Add a new class to the widget and update the UI."""
+        # Add to classes list
+        self._classes.append(new_class)
+
+        # Update data
+        DataJson()[self.widget_id] = self.get_json_data()
+        DataJson().send_changes()
+
+        # Set the new class as selected
+        if self._multiple:
+            current = StateJson()[self.widget_id]["value"]
+            if isinstance(current, list):
+                current.append(new_class.name)
+            else:
+                StateJson()[self.widget_id]["value"] = [new_class.name]
+        else:
+            StateJson()[self.widget_id]["value"] = new_class.name
+        StateJson().send_changes()
+
+    def value_changed(self, func: Callable[[Union[ObjClass, List[ObjClass]]], None]):
+        """
+        Decorator to handle value change event.
+        The decorated function receives the selected ObjClass (or list of ObjClass if multiple=True).
+
+        :param func: Function to be called when selection changes
+        :type func: Callable[[Union[ObjClass, List[ObjClass]]], None]
+        """
+        route_path = self.get_route_path(SelectClass.Routes.VALUE_CHANGED)
+        server = self._sly_app.get_server()
+        self._changes_handled = True
+
+        @server.post(route_path)
+        def _value_changed():
+            selected = self.get_selected_class()
+            if selected is not None:
+                func(selected)
+
+        return _value_changed
+
+    def _register_class_created_route(self):
+        """Register the class_created route."""
+        route_path = self.get_route_path(SelectClass.Routes.CLASS_CREATED)
+        server = self._sly_app.get_server()
+
+        @server.post(route_path)
+        def _class_created():
+            state = StateJson()[self.widget_id]["createClassDialog"]
+            class_name = state["className"].strip()
+            geometry_type_str = state["geometryType"]
+
+            # Validate class name
+            if not class_name:
+                self._show_error("Class name cannot be empty")
+                return
+
+            # Check if class with this name already exists
+            if any(cls.name == class_name for cls in self._classes):
+                self._show_error(f"Class '{class_name}' already exists")
+                return
+
+            # Get geometry type from string
+            geometry_type = shape_text_to_type.get(geometry_type_str)
+            if geometry_type is None:
+                self._show_error("Invalid geometry type")
+                return
+
+            # Generate color for the new class
+            existing_colors = [cls.color for cls in self._classes]
+            new_color = generate_rgb(existing_colors)
+
+            # Create new class
+            new_class = ObjClass(name=class_name, geometry_type=geometry_type, color=new_color)
+
+            # Add to widget
+            self._add_new_class(new_class)
+
+            # Hide dialog
+            self._hide_dialog()
+
+            # Call user's callback if set
+            if self._class_created_callback:
+                self._class_created_callback(new_class)
+
+    def class_created(self, func: Callable[[ObjClass], None]):
+        """
+        Decorator to handle new class creation event.
+        The decorated function receives the newly created ObjClass.
+
+        :param func: Function to be called when a new class is created
+        :type func: Callable[[ObjClass], None]
+        """
+        self._class_created_callback = func
+        return func

supervisely/app/widgets/select_class/template.html

@@ -0,0 +1,50 @@
+<el-select v-model="state.{{{widget.widget_id}}}.value" {% if widget._changes_handled==true %}
+	@change="post('/{{{widget.widget_id}}}/value_changed')" {% endif %}
+	:placeholder="data.{{{widget.widget_id}}}.placeholder" :filterable="data.{{{widget.widget_id}}}.filterable"
+	:multiple="data.{{{widget.widget_id}}}.multiple" :size="data.{{{widget.widget_id}}}.size">
+	<el-option v-for="item in data.{{{widget.widget_id}}}.items" :key="item.value" :label="item.label"
+		:value="item.value">
+		<i class="zmdi zmdi-circle"
+			:style="{color: 'rgb(' + item.color[0] + ',' + item.color[1] + ',' + item.color[2] + ')'}"></i>
+		{{ item.label }}
+		<span v-if="item.geometryType" style="float: right; color: #8492a6; font-size: 12px; margin-right: 20px;">
+			{{ item.geometryType }}
+		</span>
+	</el-option>
+	<el-option v-if="data.{{{widget.widget_id}}}.showAddNewClass" value="__add_new_class__" label="+ Add new class"
+		disabled @click.native.stop="state.{{{widget.widget_id}}}.createClassDialog.visible = true"
+		style="cursor: pointer;">
+		<span style="color: #409EFF; font-weight: 500;">+ Add new class</span>
+	</el-option>
+</el-select>
+
+<!-- Dialog for creating new class -->
+<el-dialog title="Create New Class" :visible.sync="state.{{{widget.widget_id}}}.createClassDialog.visible" width="450px"
+	:close-on-click-modal="false" @open="state.{{{widget.widget_id}}}.createClassDialog.showError = false">
+	<el-form label-width="120px" label-position="left">
+		<el-form-item label="Class Name">
+			<el-input v-model="state.{{{widget.widget_id}}}.createClassDialog.className" placeholder="Enter class name"
+				@input="state.{{{widget.widget_id}}}.createClassDialog.showError = false"
+				@keyup.enter.native="post('/{{{widget.widget_id}}}/class_created_cb')"></el-input>
+		</el-form-item>
+		<el-form-item label="Geometry Type">
+			<el-select v-model="state.{{{widget.widget_id}}}.createClassDialog.geometryType"
+				placeholder="Select geometry type" style="width: 100%">
+				<el-option v-for="geom in data.{{{widget.widget_id}}}.availableGeometryTypes" :key="geom.value"
+					:label="geom.label" :value="geom.value">
+				</el-option>
+			</el-select>
+		</el-form-item>
+		<div v-show="state.{{{widget.widget_id}}}.createClassDialog.showError" style="margin-top: 10px;">
+			{{{widget._error_message}}}
+		</div>
+	</el-form>
+	<span slot="footer" class="dialog-footer">
+		<el-button @click="state.{{{widget.widget_id}}}.createClassDialog.visible = false">
+			Cancel
+		</el-button>
+		<el-button type="primary" @click="post('/{{{widget.widget_id}}}/class_created_cb')">
+			Create
+		</el-button>
+	</span>
+</el-dialog>

supervisely/app/widgets/select_cuda/select_cuda.py

@@ -168,3 +168,25 @@ class SelectCudaDevice(Widget):
         :return: None
         """
         return self._select.set_value(value)
+
+    def disable(self) -> None:
+        """Disables the widget.
+
+        This method disables the widget and grays out the selector.
+
+        :return: None
+        """
+        self._disabled = True
+        self._select.disable()
+        self._refresh_button.disable()
+
+    def enable(self) -> None:
+        """Enables the widget.
+
+        This method enables the widget and makes the selector clickable.
+
+        :return: None
+        """
+        self._disabled = False
+        self._select.enable()
+        self._refresh_button.enable()

supervisely/app/widgets/select_dataset_tree/select_dataset_tree.py

@@ -5,6 +5,7 @@ from supervisely.api.api import Api
 from supervisely.app.widgets import Widget
 from supervisely.app.widgets.checkbox.checkbox import Checkbox
 from supervisely.app.widgets.container.container import Container
+from supervisely.app.widgets.field.field import Field
 from supervisely.app.widgets.select.select import Select
 from supervisely.app.widgets.tree_select.tree_select import TreeSelect
 from supervisely.project.project_type import ProjectType
@@ -97,6 +98,7 @@ class SelectDatasetTree(Widget):
         widget_id: Union[str, None] = None,
         show_select_all_datasets_checkbox: bool = True,
         width: int = 193,
+        show_selectors_labels: bool = False,
     ):
         self._api = Api.from_env()
 
@@ -114,11 +116,29 @@ class SelectDatasetTree(Widget):
         # Using environment variables to set the default values if they are not provided.
         self._project_id = project_id or env.project_id(raise_not_found=False)
         self._dataset_id = default_id or env.dataset_id(raise_not_found=False)
+        if self._project_id:
+            project_info = self._api.project.get_info_by_id(self._project_id)
+            if allowed_project_types is not None:
+                allowed_values = []
+                if not isinstance(allowed_project_types, list):
+                    allowed_project_types = [allowed_project_types]
+
+                for pt in allowed_project_types:
+                    if isinstance(pt, (ProjectType, str)):
+                        allowed_values.append(str(pt))
+
+                if project_info.type not in allowed_values:
+                    self._project_id = None
 
         self._multiselect = multiselect
         self._compact = compact
         self._append_to_body = append_to_body
 
+        # User-defined callbacks
+        self._team_changed_callbacks = []
+        self._workspace_changed_callbacks = []
+        self._project_changed_callbacks = []
+
         # Extract values from Enum to match the .type property of the ProjectInfo object.
         self._project_types = None
         if allowed_project_types is not None:
@@ -160,6 +180,7 @@ class SelectDatasetTree(Widget):
         if show_select_all_datasets_checkbox:
             self._create_select_all_datasets_checkbox(select_all_datasets)
 
+        self._show_selectors_labels = show_selectors_labels
         # Group the selectors and the dataset selector into a container.
         self._content = Container(self._widgets)
         super().__init__(widget_id=widget_id, file_path=__file__)
@@ -308,8 +329,30 @@ class SelectDatasetTree(Widget):
         """
         if not self._multiselect:
             raise ValueError("This method can only be called when multiselect is enabled.")
+        self._select_all_datasets_checkbox.uncheck()
         self._select_dataset.set_selected_by_id(dataset_ids)
 
+    def team_changed(self, func: Callable) -> Callable:
+        """Decorator to set the callback function for the team changed event."""
+        if self._compact:
+            raise ValueError("callback 'team_changed' is not available in compact mode.")
+        self._team_changed_callbacks.append(func)
+        return func
+
+    def workspace_changed(self, func: Callable) -> Callable:
+        """Decorator to set the callback function for the workspace changed event."""
+        if self._compact:
+            raise ValueError("callback 'workspace_changed' is not available in compact mode.")
+        self._workspace_changed_callbacks.append(func)
+        return func
+
+    def project_changed(self, func: Callable) -> Callable:
+        """Decorator to set the callback function for the project changed event."""
+        if self._compact:
+            raise ValueError("callback 'project_changed' is not available in compact mode.")
+        self._project_changed_callbacks.append(func)
+        return func
+
     def value_changed(self, func: Callable) -> Callable:
         """Decorator to set the callback function for the value changed event.
 
@@ -353,13 +396,13 @@ class SelectDatasetTree(Widget):
 
             if checked:
                 self._select_dataset.select_all()
-                self._select_dataset.hide()
+                self._select_dataset_field.hide()
             else:
                 self._select_dataset.clear_selected()
-                self._select_dataset.show()
+                self._select_dataset_field.show()
 
         if select_all_datasets:
-            self._select_dataset.hide()
+            self._select_dataset_field.hide()
             select_all_datasets_checkbox.check()
 
         self._widgets.append(select_all_datasets_checkbox)
@@ -390,9 +433,10 @@ class SelectDatasetTree(Widget):
             self._select_dataset.set_selected_by_id(self._dataset_id)
         if select_all_datasets:
             self._select_dataset.select_all()
+        self._select_dataset_field = Field(self._select_dataset, title="Dataset")
 
         # Adding the dataset selector to the list of widgets to be added to the container.
-        self._widgets.append(self._select_dataset)
+        self._widgets.append(self._select_dataset_field)
 
     def _create_selectors(self, team_is_selectable: bool, workspace_is_selectable: bool):
         """Create the team, workspace, and project selectors.
@@ -412,6 +456,9 @@ class SelectDatasetTree(Widget):
             self._select_workspace.set(items=self._get_select_items(team_id=team_id))
             self._team_id = team_id
 
+            for callback in self._team_changed_callbacks:
+                callback(team_id)
+
         def workspace_selector_handler(workspace_id: int):
             """Handler function for the event when the workspace selector value changes.
 
@@ -421,6 +468,9 @@ class SelectDatasetTree(Widget):
             self._select_project.set(items=self._get_select_items(workspace_id=workspace_id))
             self._workspace_id = workspace_id
 
+            for callback in self._workspace_changed_callbacks:
+                callback(workspace_id)
+
         def project_selector_handler(project_id: int):
             """Handler function for the event when the project selector value changes.
 
@@ -435,7 +485,10 @@ class SelectDatasetTree(Widget):
                 and self._select_all_datasets_checkbox.is_checked()
             ):
                 self._select_dataset.select_all()
-                self._select_dataset.hide()
+                self._select_dataset_field.hide()
+
+            for callback in self._project_changed_callbacks:
+                callback(project_id)
 
         self._select_team = Select(
             items=self._get_select_items(),
@@ -446,6 +499,7 @@ class SelectDatasetTree(Widget):
         self._select_team.set_value(self._team_id)
         if not team_is_selectable:
             self._select_team.disable()
+        self._select_team_field = Field(self._select_team, title="Team")
 
         self._select_workspace = Select(
             items=self._get_select_items(team_id=self._team_id),
@@ -456,6 +510,7 @@ class SelectDatasetTree(Widget):
         self._select_workspace.set_value(self._workspace_id)
         if not workspace_is_selectable:
             self._select_workspace.disable()
+        self._select_workspace_field = Field(self._select_workspace, title="Workspace")
 
         self._select_project = Select(
             items=self._get_select_items(workspace_id=self._workspace_id),
@@ -464,14 +519,17 @@ class SelectDatasetTree(Widget):
             width_px=self._width,
         )
         self._select_project.set_value(self._project_id)
+        self._select_project_field = Field(self._select_project, title="Project")
 
-        # Register the event handlers.
+        # Register the event handlers._select_project
         self._select_team.value_changed(team_selector_handler)
         self._select_workspace.value_changed(workspace_selector_handler)
         self._select_project.value_changed(project_selector_handler)
 
         # Adding widgets to the list, so they can be added to the container.
-        self._widgets.extend([self._select_team, self._select_workspace, self._select_project])
+        self._widgets.extend(
+            [self._select_team_field, self._select_workspace_field, self._select_project_field]
+        )
 
     def _get_select_items(self, **kwargs) -> List[Select.Item]:
         """Get the list of items for the team, workspace, and project selectors.