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

supervisely/app/widgets/activity_feed/activity_feed.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+from supervisely.app import DataJson
+from supervisely.app.widgets import Widget
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+
+class ActivityFeed(Widget):
+    """ActivityFeed is a widget that displays a vertical list of activity items with status indicators.
+    Similar to a timeline or activity log showing sequential events with their current status.
+
+    Each item can contain a custom widget as content and displays a status indicator (pending, in process, completed, failed).
+    Items are automatically numbered if no number is provided.
+
+    Read about it in `Developer Portal <https://developer.supervisely.com/app-development/widgets/layouts-and-containers/activity-feed>`_
+        (including screenshots and examples).
+
+    :param items: List of ActivityFeed.Item objects to display
+    :type items: Optional[List[ActivityFeed.Item]]
+    :param widget_id: An identifier of the widget.
+    :type widget_id: str, optional
+
+    :Usage example:
+    .. code-block:: python
+
+        from supervisely.app.widgets import ActivityFeed, Text
+
+        # Create items with custom content
+        item1 = ActivityFeed.Item(
+            content=Text("Processing dataset"),
+            status="completed"
+        )
+        item2 = ActivityFeed.Item(
+            content=Text("Training model"),
+            status="in_progress",
+            number=2
+        )
+        item3 = ActivityFeed.Item(
+            content=Text("Generating report"),
+            status="pending"
+        )
+
+        # Create activity feed
+        feed = ActivityFeed(items=[item1, item2, item3])
+
+        # Add item during runtime
+        new_item = ActivityFeed.Item(
+            content=Text("Deploy model"),
+            status="pending"
+        )
+        feed.add_item(new_item)
+
+        # Update status by item number
+        feed.set_status(2, "completed")
+
+        # Get item status
+        status = feed.get_status(2)
+    """
+
+    class Item:
+        """Represents a single item in the ActivityFeed.
+
+        :param content: Widget to display as the item content
+        :type content: Widget
+        :param status: Status of the item (pending, in_progress, completed, failed)
+        :type status: Literal["pending", "in_progress", "completed", "failed"]
+        :param number: Position number in the feed (auto-assigned if not provided)
+        :type number: Optional[int]
+        """
+
+        def __init__(
+            self,
+            content: Widget,
+            status: Literal["pending", "in_progress", "completed", "failed"] = "pending",
+            number: Optional[int] = None,
+        ) -> ActivityFeed.Item:
+            self.content = content
+            self.status = status
+            self.number = number
+            self._validate_status()
+
+        def _validate_status(self):
+            valid_statuses = ["pending", "in_progress", "completed", "failed"]
+            if self.status not in valid_statuses:
+                raise ValueError(
+                    f"Invalid status '{self.status}'. Must be one of: {', '.join(valid_statuses)}"
+                )
+
+        def to_json(self):
+            return {
+                "number": self.number,
+                "status": self.status,
+            }
+
+    def __init__(
+        self,
+        items: Optional[List[ActivityFeed.Item]] = None,
+        widget_id: Optional[str] = None,
+    ):
+        self._items = items if items is not None else []
+        self._auto_assign_numbers()
+        super().__init__(widget_id=widget_id, file_path=__file__)
+
+    def _auto_assign_numbers(self):
+        """Automatically assign numbers to items that don't have them."""
+        next_number = 1
+        for item in self._items:
+            if item.number is None:
+                item.number = next_number
+            next_number = max(next_number, item.number) + 1
+
+    def get_json_data(self) -> Dict:
+        """Returns dictionary with widget data.
+
+        :return: Dictionary with items data
+        :rtype: Dict
+        """
+        return {
+            "items": [item.to_json() for item in self._items],
+        }
+
+    def get_json_state(self) -> Dict:
+        """Returns dictionary with widget state (empty for this widget).
+
+        :return: Empty dictionary
+        :rtype: Dict
+        """
+        return {}
+
+    def add_item(
+        self,
+        item: Optional[ActivityFeed.Item] = None,
+        content: Optional[Widget] = None,
+        status: Literal["pending", "in_progress", "completed", "failed"] = "pending",
+        number: Optional[int] = None,
+    ) -> None:
+        """Add a new item to the activity feed.
+
+        You can either pass an ActivityFeed.Item object or provide content and status separately.
+
+        :param item: ActivityFeed.Item to add
+        :type item: Optional[ActivityFeed.Item]
+        :param content: Widget content (used if item is not provided)
+        :type content: Optional[Widget]
+        :param status: Status of the item (used if item is not provided)
+        :type status: Literal["pending", "in_progress", "completed", "failed"]
+        :param number: Position number (auto-assigned if not provided)
+        :type number: Optional[int]
+        """
+        if item is None:
+            if content is None:
+                raise ValueError("Either 'item' or 'content' must be provided")
+            item = ActivityFeed.Item(content=content, status=status, number=number)
+
+        if item.number is None:
+            # Auto-assign number
+            if self._items:
+                item.number = max(i.number for i in self._items) + 1
+            else:
+                item.number = 1
+
+        self._items.append(item)
+        self.update_data()
+        DataJson().send_changes()
+
+    def remove_item(self, number: int) -> None:
+        """Remove an item from the activity feed by its number.
+
+        :param number: Number of the item to remove. Starts from 1.
+        :type number: int
+        """
+        self._items = [item for item in self._items if item.number != number]
+        self.update_data()
+        DataJson().send_changes()
+
+    def set_status(
+        self,
+        number: int,
+        status: Literal["pending", "in_progress", "completed", "failed"],
+    ) -> None:
+        """Update the status of an item by its number.
+
+        :param number: Number of the item to update. Starts from 1.
+        :type number: int
+        :param status: New status for the item
+        :type status: Literal["pending", "in_progress", "completed", "failed"]
+        """
+        for i, item in enumerate(self._items):
+            if item.number == number:
+                item.status = status
+                item._validate_status()
+                DataJson()[self.widget_id]["items"][i]["status"] = status
+                DataJson().send_changes()
+                return
+        raise ValueError(f"Item with number {number} not found")
+
+    def get_status(self, number: int) -> str:
+        """Get the status of an item by its number.
+
+        :param number: Number of the item. Starts from 1.
+        :type number: int
+        :return: Status of the item
+        :rtype: str
+        """
+        for item in self._items:
+            if item.number == number:
+                return item.status
+        raise ValueError(f"Item with number {number} not found")
+
+    def get_items(self) -> List[ActivityFeed.Item]:
+        """Get all items in the activity feed.
+
+        :return: List of all items
+        :rtype: List[ActivityFeed.Item]
+        """
+        return self._items
+
+    def clear(self) -> None:
+        """Remove all items from the activity feed."""
+        self._items = []
+        self.update_data()
+        DataJson().send_changes()
+
+    def set_items(self, items: List[ActivityFeed.Item]) -> None:
+        """Replace all items in the activity feed.
+
+        :param items: New list of items
+        :type items: List[ActivityFeed.Item]
+        """
+        self._items = items
+        self._auto_assign_numbers()
+        self.update_data()
+        DataJson().send_changes()

supervisely/app/widgets/activity_feed/style.css

@@ -0,0 +1,78 @@
+.sly-activity-feed {
+  padding: 10px;
+}
+
+.sly-activity-feed-item {
+  display: flex;
+  position: relative;
+  padding-bottom: 20px;
+}
+
+.sly-activity-feed-item:last-child {
+  padding-bottom: 0;
+}
+
+.sly-activity-feed-item:not(:last-child) .sly-activity-feed-line {
+  display: block;
+}
+
+.sly-activity-feed-marker {
+  flex-shrink: 0;
+  width: 40px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  position: relative;
+}
+
+.sly-activity-feed-circle {
+  width: 16px;
+  height: 16px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+  font-size: 10px;
+  color: white;
+  z-index: 1;
+}
+
+.sly-activity-feed-circle.completed {
+  background-color: #67C23A;
+}
+
+.sly-activity-feed-circle.failed {
+  background-color: #F56C6C;
+}
+
+.sly-activity-feed-circle.in_progress {
+  background-color: #409EFF;
+}
+
+.sly-activity-feed-circle.pending {
+  background-color: #909399;
+}
+
+.sly-activity-feed-line {
+  position: absolute;
+  top: 16px;
+  left: 50%;
+  transform: translateX(-50%);
+  width: 2px;
+  height: calc(100% + 4px);
+  background-color: #E4E7ED;
+  display: none;
+}
+
+.sly-activity-feed-content {
+  flex: 1;
+  padding-left: 10px;
+  padding-top: 0px;
+}
+
+.sly-activity-feed-number {
+  font-size: 11px;
+  color: #909399;
+  margin-top: 4px;
+}

supervisely/app/widgets/activity_feed/template.html

@@ -0,0 +1,22 @@
+<link rel="stylesheet" href="./sly/css/app/widgets/activity_feed/style.css" />
+
+<div class="sly-activity-feed">
+  {% for item in widget._items %}
+  <div class="sly-activity-feed-item" v-if="data.{{{widget.widget_id}}}.items[{{{loop.index0}}}]">
+    <div class="sly-activity-feed-marker">
+      <div class="sly-activity-feed-circle" :class="data.{{{widget.widget_id}}}.items[{{{loop.index0}}}].status">
+        <i v-if="data.{{{widget.widget_id}}}.items[{{{loop.index0}}}].status === 'completed'" class="el-icon-check"></i>
+        <i v-else-if="data.{{{widget.widget_id}}}.items[{{{loop.index0}}}].status === 'failed'"
+          class="el-icon-close"></i>
+        <i v-else-if="data.{{{widget.widget_id}}}.items[{{{loop.index0}}}].status === 'in_progress'"
+          class="el-icon-loading"></i>
+        <i v-else class="el-icon-time"></i>
+      </div>
+      <div class="sly-activity-feed-line"></div>
+    </div>
+    <div class="sly-activity-feed-content">
+      {{{item.content}}}
+    </div>
+  </div>
+  {% endfor %}
+</div>

supervisely/app/widgets/card/card.py

@@ -157,3 +157,23 @@ class Card(Widget):
         :rtype: bool
         """
         return self._disabled["disabled"]
+
+    @property
+    def description(self) -> Optional[str]:
+        """Description of the card.
+
+        :return: Description of the card.
+        :rtype: Optional[str]
+        """
+        return self._description
+
+    @description.setter
+    def description(self, value: str) -> None:
+        """Sets the description of the card.
+
+        :param value: Description of the card.
+        :type value: str
+        """
+        self._description = value
+        StateJson()[self.widget_id]["description"] = self._description
+        StateJson().send_changes()

supervisely/app/widgets/classes_list_selector/classes_list_selector.py

@@ -1,23 +1,25 @@
-from typing import List, Optional, Union
+from typing import Callable, List, Optional, Union
 
 from supervisely import ObjClass, ObjClassCollection
-from supervisely.app import StateJson
-from supervisely.app.widgets import Button, NotificationBox, Widget, generate_id
+from supervisely.app import DataJson, StateJson
+from supervisely.app.widgets import NotificationBox, 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.alpha_mask import AlphaMask
 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
 
 type_to_shape_text = {
     AnyGeometry: "any shape",
@@ -29,34 +31,57 @@ type_to_shape_text = {
     Point: "point",
     Cuboid2d: "cuboid 2d",  #
     Cuboid3d: "cuboid 3d",
-    Pointcloud: "pointcloud",  #  # "zmdi zmdi-border-clear"
+    Pointcloud: "pointcloud",  # "zmdi zmdi-border-clear"
     MultichannelBitmap: "n-channel mask",  # "zmdi zmdi-collection-item"
     Point3d: "point 3d",  # "zmdi zmdi-select-all"
     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 ClassesListSelector(Widget):
     class Routes:
         CHECKBOX_CHANGED = "checkbox_cb"
+        CLASS_CREATED = "class_created_cb"
 
     def __init__(
         self,
         classes: Optional[Union[List[ObjClass], ObjClassCollection]] = [],
         multiple: Optional[bool] = False,
         empty_notification: Optional[NotificationBox] = None,
+        allow_new_classes: Optional[bool] = False,
         widget_id: Optional[str] = None,
     ):
-        self._classes = classes
+        # 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._multiple = multiple
+        self._allow_new_classes = allow_new_classes
+        self._class_created_handled = False
         if empty_notification is None:
             empty_notification = NotificationBox(
                 title="No classes",
                 description="No classes to select.",
             )
         self.empty_notification = empty_notification
+        self._error_message = Text("", status="error", font_size=13)
         super().__init__(widget_id=widget_id, file_path=__file__)
 
     def get_json_data(self):
@@ -65,14 +90,29 @@ class ClassesListSelector(Widget):
             shape_text = type_to_shape_text.get(cls.geometry_type)
             class_dict = {**cls.to_json(), "shape_text": shape_text.upper() if shape_text else ""}
             classes_list.append(class_dict)
-        return {"classes": classes_list}
+        return {
+            "classes": classes_list,
+            "availableGeometryTypes": available_geometry_types,
+        }
 
     def get_json_state(self):
-        return {"selected": [False for _ in self._classes]}
+        return {
+            "selected": [False for _ in self._classes],
+            "createClassDialog": {
+                "visible": False,
+                "className": "",
+                "geometryType": "rectangle",
+                "showError": False,
+            },
+        }
 
     def set(self, classes: Union[List[ObjClass], ObjClassCollection]):
         selected_classes = [cls.name for cls in self.get_selected_classes()]
-        self._classes = classes
+        # Convert to list for internal use
+        if isinstance(classes, ObjClassCollection):
+            self._classes = list(classes)
+        else:
+            self._classes = list(classes) if classes else []
         StateJson()[self.widget_id]["selected"] = [
             cls.name in selected_classes for cls in self._classes
         ]
@@ -110,6 +150,33 @@ class ClassesListSelector(Widget):
     def get_all_classes(self):
         return self._classes
 
+    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)
+
+        # Add selection state for the new class (selected by default)
+        StateJson()[self.widget_id]["selected"].append(True)
+
+        # Update data to reflect the new class in the UI
+        self.update_data()
+        DataJson().send_changes()
+        StateJson().send_changes()
+
     def selection_changed(self, func):
         route_path = self.get_route_path(ClassesListSelector.Routes.CHECKBOX_CHANGED)
         server = self._sly_app.get_server()
@@ -121,3 +188,48 @@ class ClassesListSelector(Widget):
             func(selected)
 
         return _click
+
+    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]
+        """
+        route_path = self.get_route_path(ClassesListSelector.Routes.CLASS_CREATED)
+        server = self._sly_app.get_server()
+        self._class_created_handled = True
+
+        @server.post(route_path)
+        def _class_created():
+            state = StateJson()[self.widget_id]["createClassDialog"]
+            class_name = state["className"].strip()
+            geometry_type_str = state["geometryType"]
+
+            if not class_name:
+                self._show_error("Class name cannot be empty")
+                return
+
+            if any(cls.name == class_name for cls in self._classes):
+                self._show_error(f"Class '{class_name}' already exists")
+                return
+
+            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)
+
+            self._add_new_class(new_class)
+            self._hide_dialog()
+
+            func(new_class)
+
+        return _class_created