supervisely 6.73.427__py3-none-any.whl → 6.73.429__py3-none-any.whl

supervisely/app/widgets/__init__.py

@@ -62,6 +62,7 @@ from supervisely.app.widgets.video_player.video_player import VideoPlayer
 from supervisely.app.widgets.radio_group.radio_group import RadioGroup
 from supervisely.app.widgets.switch.switch import Switch
 from supervisely.app.widgets.input_tag.input_tag import InputTag
+
 from supervisely.app.widgets.file_viewer.file_viewer import FileViewer
 from supervisely.app.widgets.switch.switch import Switch
 from supervisely.app.widgets.folder_thumbnail.folder_thumbnail import FolderThumbnail
@@ -152,6 +153,7 @@ from supervisely.app.widgets.bokeh.bokeh import Bokeh
 from supervisely.app.widgets.run_app_button.run_app_button import RunAppButton
 from supervisely.app.widgets.select_collection.select_collection import SelectCollection
 from supervisely.app.widgets.sampling.sampling import Sampling
+from supervisely.app.widgets.input_tag_list.input_tag_list import InputTagList
 from supervisely.app.widgets.deploy_model.deploy_model import DeployModel
 from supervisely.app.widgets.dropdown_checkbox_selector.dropdown_checkbox_selector import (
     DropdownCheckboxSelector,

supervisely/app/widgets/input_tag/input_tag.py

@@ -1,4 +1,4 @@
-from typing import Dict, Union
+from typing import Dict, Union, Callable
 
 from supervisely.annotation.tag import Tag
 from supervisely.annotation.tag_meta import TagMeta, TagValueType
@@ -30,6 +30,18 @@ VALUE_TYPES = [
 
 
 class InputTag(Widget):
+    """Widget for inputting a single tag value based on its TagMeta information. Accepts various input types depending on the tag's value type. Returns the tag value when requested.
+
+    :param tag_meta: Tag metadata
+    :type tag_meta: TagMeta
+    :param max_width: Maximum width of the widget in pixels, defaults to 300
+    :type max_width: int
+    :param hide_switch: Whether to hide the activation switch, defaults to False
+    :type hide_switch: bool
+    :param widget_id: Unique identifier for the widget, defaults to None
+    :type widget_id: int
+    """
+
     def __init__(
         self,
         tag_meta: TagMeta,
@@ -74,35 +86,79 @@ class InputTag(Widget):
         self._input_widgets[str(TagValueType.ANY_STRING)] = Input(type="textarea")
         self._input_widgets[str(TagValueType.ONEOF_STRING)] = RadioGroup(items=[])
 
-    def _get_max_width(self, value):
+    def _get_max_width(self, value) -> str:
+        """Get the maximum width for the widget.
+        Ensures the width is at least 150 pixels.
+
+        :param value: Desired maximum width in pixels.
+        :type value: int
+        :return: Maximum width for the widget
+        :rtype: str
+        """
         if value < 150:
             value = 150
         return f"{value}px"
 
-    def get_tag_meta(self):
+    def get_tag_meta(self) -> TagMeta:
+        """Get the tag metadata.
+
+        :return: Tag metadata
+        :rtype: TagMeta
+        """
         return self._tag_meta
 
-    def activate(self):
+    def activate(self) -> None:
+        """Activate the widget."""
         self._activation_widget.on()
 
-    def deactivate(self):
+    def deactivate(self) -> None:
+        """Deactivate the widget."""
         self._activation_widget.off()
 
-    def is_active(self):
+    def is_active(self) -> bool:
+        """Check if the widget is active.
+
+        :return: True if the widget is active, False otherwise
+        :rtype: bool
+        """
         return self._activation_widget.is_switched()
 
     @property
-    def value(self):
+    def value(self) -> Union[str, int, None]:
+        """Get the current value of the tag.
+
+        :return: Current value of the tag
+        :rtype: Union[str, int, None]
+        """
         return self._get_value()
 
     @value.setter
-    def value(self, value):
+    def value(self, value: Union[str, int, None]) -> None:
+        """Set the current value of the tag.
+
+        :param value: Current value of the tag
+        :type value: Union[str, int, None]
+        :return: None
+        """
         self._set_value(value)
 
-    def is_valid_value(self, value):
+    def is_valid_value(self, value: Union[str, int, None]) -> bool:
+        """Check if the value is valid for the tag.
+
+        :param value: Value to check
+        :type value: Union[str, int, None]
+        :return: True if the value is valid, False otherwise
+        :rtype: bool
+        """
         return self._tag_meta.is_valid_value(value)
 
-    def set(self, tag: Union[Tag, None]):
+    def set(self, tag: Union[Tag, None]) -> None:
+        """Set the tag value.
+
+        :param tag: Tag to set
+        :type tag: Union[Tag, None]
+        :return: None
+        """
         if tag is None:
             self._set_default_value()
             self.deactivate()
@@ -110,13 +166,23 @@ class InputTag(Widget):
             self._set_value(tag.value)
             self.activate()
 
-    def get_tag(self):
+    def get_tag(self) -> Union[Tag, None]:
+        """Get the current tag.
+
+        :return: Current tag
+        :rtype: Union[Tag, None]
+        """
         if not self._hide_switch and not self.is_active():
             return None
         tag_value = self._get_value()
         return Tag(self._tag_meta, tag_value)
 
-    def _get_value(self):
+    def _get_value(self) -> Union[str, int, None]:
+        """Get the current value of the tag.
+
+        :return: Current value of the tag
+        :rtype: Union[str, int, None]
+        """
         input_widget = self._input_widgets[self._tag_meta.value_type]
         if isinstance(input_widget, Empty):
             return None
@@ -143,7 +209,12 @@ class InputTag(Widget):
         if isinstance(input_widget, RadioGroup):
             input_widget.set_value(None)
 
-    def get_json_data(self):
+    def get_json_data(self) -> Dict:
+        """Get the JSON representation of the tag.
+
+        :return: JSON representation of the tag
+        :rtype: Dict
+        """
         return {
             "name": self._name,
             "valueType": self._value_type_name,
@@ -151,9 +222,19 @@ class InputTag(Widget):
         }
 
     def get_json_state(self) -> Dict:
+        """Get the JSON representation of the tag state.
+
+        :return: JSON representation of the tag state
+        :rtype: Dict
+        """
         return None
 
-    def value_changed(self, func):
+    def value_changed(self, func) -> Callable:
+        """Decorator to register a callback function for selection changes.
+
+        :param func: Callback function
+        :type func: Callable
+        """
         for value_type, input_widget in self._input_widgets.items():
             if isinstance(input_widget, Empty):
                 self._value_changed_callbacks[value_type] = func
@@ -168,7 +249,13 @@ class InputTag(Widget):
     def selection_changed(self, func):
         return self._activation_widget.value_changed(func)
 
-    def set_tag_meta(self, tag_meta: TagMeta):
+    def set_tag_meta(self, tag_meta: TagMeta) -> None:
+        """Set the tag metadata.
+
+        :param tag_meta: Tag metadata to set
+        :type tag_meta: TagMeta
+        :return: None
+        """
         self._tag_meta = tag_meta
         self._value_type_name = VALUE_TYPE_NAME[self._tag_meta.value_type]
         self._name = f"<b>{self._tag_meta.name}</b>"

supervisely/app/widgets/input_tag_list/input_tag_list.py

@@ -0,0 +1,274 @@
+from typing import List, Union, Dict, Callable
+
+from supervisely.app.widgets import Widget
+from supervisely import TagMeta, TagMetaCollection, Tag
+from supervisely.annotation.tag_meta import TagValueType
+from supervisely.app.content import DataJson, StateJson
+from supervisely.imaging.color import rgb2hex
+
+
+class InputTagList(Widget):
+    """Store and manage a list of input tags. Class accepts a list of TagMeta objects and provides methods to interact with them.
+
+    :param tag_metas: List of TagMeta objects or a TagMetaCollection, defaults to an empty list
+    :type tag_metas: Union[List[TagMeta], TagMetaCollection], optional
+    :param max_width: Maximum width of the widget in pixels, defaults to 300
+    :type max_width: int, optional
+    :param max_height: Maximum height of the widget in pixels, defaults to 50
+    :type max_height: int, optional
+    :param multiple: Whether to allow multiple tags to be selected, defaults to False
+    :type multiple: bool, optional
+    :param widget_id: Unique identifier for the widget, defaults to None
+    :type widget_id: int, optional
+    """
+
+    class VALUE_TYPES:
+        """Value types for input tags. Classifies the different types of values that tags can have."""
+
+        none = str(TagValueType.NONE)
+        any_string = str(TagValueType.ANY_STRING)
+        one_of = str(TagValueType.ONEOF_STRING)
+        number = str(TagValueType.ANY_NUMBER)
+
+    VALUE_TYPE_NAME = {
+        str(TagValueType.NONE): "NONE",
+        str(TagValueType.ANY_STRING): "TEXT",
+        str(TagValueType.ONEOF_STRING): "ONE OF",
+        str(TagValueType.ANY_NUMBER): "NUMBER",
+    }
+
+    def get_default_value(self, tag_meta: TagMeta) -> Union[str, int, None]:
+        """Get default value for the tag based on its meta information.
+        If the tag has a predefined set of possible values (ONEOF_STRING), return the first one.
+        For other types, return a standard default value:
+        1. NONE: None
+        2. ANY_STRING: ""
+        3. ANY_NUMBER: 0
+
+        :param tag_meta: Tag metadata
+        :type tag_meta: TagMeta
+        :return: Default value for the tag
+        :rtype: Union[str, int, None]
+        """
+        DEFAULT_VALUES = {
+            str(TagValueType.NONE): None,
+            str(TagValueType.ANY_STRING): "",
+            str(TagValueType.ANY_NUMBER): 0,
+        }
+        if tag_meta.value_type == str(TagValueType.ONEOF_STRING):
+            return tag_meta.possible_values[0]
+        else:
+            return DEFAULT_VALUES[tag_meta.value_type]
+
+    class Routes:
+        """Routes for the widget events. Classifies the different types of events that can occur within the widget."""
+
+        CHECKBOX_CHANGED = "checkbox_cb"
+
+    def __init__(
+        self,
+        tag_metas: Union[List[TagMeta], TagMetaCollection] = [],
+        max_width: int = 300,
+        max_height: int = 50,
+        multiple: bool = False,
+        widget_id: int = None,
+    ):
+        self._tag_metas = tag_metas
+        self._max_width = self._get_max_width(max_width)
+        self._max_height = self._get_max_height(max_height)
+        self._multiple = multiple
+
+        super().__init__(widget_id=widget_id, file_path=__file__)
+
+    def _get_max_width(self, value) -> str:
+        """Get the maximum width for the widget.
+        Ensures the width is at least 150 pixels.
+
+        :param value: Desired maximum width in pixels.
+        :type value: int
+        :return: Maximum width for the widget
+        :rtype: str
+        """
+        if value < 150:
+            value = 150
+        return f"{value}px"
+
+    def _get_max_height(self, value) -> str:
+        """Get the maximum height for the widget.
+        Ensures the height is at least 100 pixels.
+
+        :param value: Desired maximum height in pixels.
+        :type value: int
+        :return: Maximum height for the widget
+        :rtype: str
+        """
+        if value < 100:
+            value = 100
+        return f"{value}px"
+
+    def get_json_data(self) -> Dict:
+        """Get JSON data for the widget.
+
+        :return: JSON data for the widget
+        :rtype: Dict
+        """
+        return {
+            "maxWidth": self._max_width,
+            "maxHeight": self._max_height,
+            "tags": [
+                {
+                    "name": tag_meta.name,
+                    "valueType": tag_meta.value_type,
+                    "valueTypeText": self.VALUE_TYPE_NAME[tag_meta.value_type],
+                    "color": rgb2hex(tag_meta.color),
+                    "possible_values": tag_meta.possible_values,
+                }
+                for tag_meta in self._tag_metas
+            ],
+        }
+
+    def get_json_state(self) -> Dict:
+        """Get JSON state for the widget.
+
+        :return: JSON state for the widget
+        :rtype: Dict
+        """
+        return {
+            "selected": [False for _ in self._tag_metas],
+            "values": [self.get_default_value(tm) for tm in self._tag_metas],
+        }
+
+    def get_selected_tag_metas(self) -> List[TagMeta]:
+        """Get selected tag metas for the widget.
+
+        :return: List of selected tag metas
+        :rtype: List[TagMeta]
+        """
+        return [
+            tm
+            for selected, tm in zip(StateJson()[self.widget_id]["selected"], self._tag_metas)
+            if selected
+        ]
+
+    def get_selected_tags(self) -> List[Tag]:
+        """Get selected tags for the widget.
+
+        :return: List of selected tags
+        :rtype: List[Tag]
+        """
+        return [
+            Tag(meta=tm, value=value)
+            for selected, value, tm in zip(
+                StateJson()[self.widget_id]["selected"],
+                StateJson()[self.widget_id]["values"],
+                self._tag_metas,
+            )
+            if selected
+        ]
+
+    def get_all_tags(self) -> Union[List[TagMeta], TagMetaCollection]:
+        """Get all tags for the widget.
+
+        :return: List of all tag metas
+        :rtype: Union[List[TagMeta], TagMetaCollection]
+        """
+        return [
+            Tag(meta=tm, value=value)
+            for value, tm in zip(
+                StateJson()[self.widget_id]["values"],
+                self._tag_metas,
+            )
+        ]
+
+    def set(self, tag_metas: Union[List[TagMeta], TagMetaCollection]) -> None:
+        """Set tag metas for the widget.
+
+        :param tag_metas: Tag metas to set
+        :type tag_metas: Union[List[TagMeta], TagMetaCollection]
+        :return: None
+        """
+        self._tag_metas = tag_metas
+        DataJson()[self.widget_id] = self.get_json_data()
+        DataJson().send_changes()
+        StateJson()[self.widget_id] = self.get_json_state()
+        StateJson().send_changes()
+
+    def set_values(self, values_dict: Dict) -> None:
+        """Set values for the widget.
+
+        :param values_dict: Dictionary of values to set
+        :type values_dict: Dict
+        :return: None
+        """
+        current_values = StateJson()[self.widget_id]["values"]
+        values = [
+            values_dict.get(tm.name, current_values[idx]) for idx, tm in enumerate(self._tag_metas)
+        ]
+        StateJson()[self.widget_id]["values"] = values
+        StateJson().send_changes()
+
+    def select_all(self) -> None:
+        """Select all tags for the widget.
+
+        :return: None
+        """
+        StateJson()[self.widget_id]["selected"] = [True for _ in self._tag_metas]
+        StateJson().send_changes()
+
+    def deselect_all(self) -> None:
+        """Deselect all tags for the widget.
+
+        :return: None
+        """
+        StateJson()[self.widget_id]["selected"] = [False for _ in self._tag_metas]
+        StateJson().send_changes()
+
+    def select(self, names: List[str]) -> None:
+        """Select tags for the widget.
+
+        :param names: List of tag names to select
+        :type names: List[str]
+        :return: None
+        """
+        selected = [tm.name in names for tm in self._tag_metas]
+        StateJson()[self.widget_id]["selected"] = selected
+        StateJson().send_changes()
+
+    def deselect(self, names: List[str]) -> None:
+        """Deselect tags for the widget.
+
+        :param names: List of tag names to deselect
+        :type names: List[str]
+        :return: None
+        """
+        selected = StateJson()[self.widget_id]["selected"]
+        for idx, tm in enumerate(self._tag_metas):
+            if tm.name in names:
+                selected[idx] = False
+        StateJson()[self.widget_id]["selected"] = selected
+        StateJson().send_changes()
+
+    def get_all_tag_metas(self) -> List[TagMeta]:
+        """Get all tag metas for the widget.
+
+        :return: List of all tag metas
+        :rtype: List[TagMeta]
+        """
+        return self._tag_metas
+
+    def selection_changed(self, func: Callable) -> Callable:
+        """Decorator to register a callback function for selection changes.
+
+        :param func: Callback function
+        :type func: Callable
+        """
+        route_path = self.get_route_path(InputTagList.Routes.CHECKBOX_CHANGED)
+        server = self._sly_app.get_server()
+        self._checkboxes_handled = True
+
+        @server.post(route_path)
+        def _click():
+            selected = self.get_selected_tag_metas()
+            func(selected)
+
+        return _click

supervisely/app/widgets/input_tag_list/template.html

@@ -0,0 +1,70 @@
+<div :style="{
+		'display': 'flex',
+    	'flex-direction': 'column',
+		'max-width': data.{{{widget.widget_id}}}.maxWidth,
+    'max-height': data.{{{widget.widget_id}}}.maxHeight,
+	}">
+  {% if widget._multiple %}
+  <div>
+    <el-button style="margin-right: 10px" type="text" {% if widget._checkboxes_handled %} @click="{
+					state.{{{widget.widget_id}}}.selected = state.{{{widget.widget_id}}}.selected.map(() => true);
+					post('/{{{widget.widget_id}}}/checkbox_cb');
+				}" {% else %}
+      @click="state.{{{widget.widget_id}}}.selected = state.{{{widget.widget_id}}}.selected.map(() => true)" {% endif
+      %}>
+      <i class="zmdi zmdi-check-all"></i>
+      Select all
+    </el-button>
+    <el-button style="margin-right: 10px" type="text" {% if widget._checkboxes_handled %} @click="{
+					state.{{{widget.widget_id}}}.selected = state.{{{widget.widget_id}}}.selected.map(() => false);
+					post('/{{{widget.widget_id}}}/checkbox_cb');
+				}" {% else %}
+      @click="state.{{{widget.widget_id}}}.selected = state.{{{widget.widget_id}}}.selected.map(() => false)" {% endif
+      %}>
+      <i class="zmdi zmdi-square-o"></i>
+      Deselect all
+    </el-button>
+  </div>
+  {% endif %}
+  <div style="
+			display: flex;
+			flex-direction: column;
+			gap: 2px;
+			overflow-y: auto;
+			overflow-x: hidden;
+		">
+    <div v-for="(tag, idx) in data.{{{widget.widget_id}}}.tags" class="fflex" style="gap: 4px">
+      <el-checkbox style="flex: none" v-model="state.{{{widget.widget_id}}}.selected[idx]" {% if
+        widget._checkboxes_handled %} {% if not widget._multiple %} @change="() => {
+							if ($event.target.checked) {
+								state.{{{widget.widget_id}}}.selected = state.{{{widget.widget_id}}}.selected.map((_, i) => i == idx);
+							}
+							post('/{{{widget.widget_id}}}/checkbox_cb');
+						}" {% else %} @change="() => {
+							post('/{{{widget.widget_id}}}/checkbox_cb');
+						}" {% endif %} {% else %} {% if not widget._multiple %}
+        @change="if ($event.target.checked) {state.{{{widget.widget_id}}}.selected = state.{{{widget.widget_id}}}.selected.map((_, i) => i == idx);}"
+        {% endif %} {% endif %}>
+      </el-checkbox>
+      <i class="zmdi zmdi-label" :style="{color: tag.color}" style="flex: none"></i>
+      <div class="fflex" style="flex: 1; overflow: hidden; text-overflow: ellipsis">
+        <b style="width: 100%; overflow: hidden; text-overflow: ellipsis">{{tag.name}}</b>
+      </div>
+      <div v-if="state.{{{widget.widget_id}}}.selected[idx]">
+        <div v-if="tag.valueType == '{{{widget.VALUE_TYPES.any_string}}}'">
+          <el-input v-model="state.{{{widget.widget_id}}}.values[idx]" size="mini" style="width: 140px"></el-input>
+        </div>
+        <div v-if="tag.valueType == '{{{widget.VALUE_TYPES.one_of}}}'">
+          <el-select v-model="state.{{{widget.widget_id}}}.values[idx]" size="mini" style="width: 140px">
+            <el-option v-for="item in tag.possible_values" :key="item" :label="item" :value="item">
+            </el-option>
+          </el-select>
+        </div>
+        <div v-if="tag.valueType == '{{{widget.VALUE_TYPES.number}}}'">
+          <el-input-number :controls="false" v-model="state.{{{widget.widget_id}}}.values[idx]" size="mini"
+            style="width: 140px"></el-input-number>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>

supervisely/convert/pointcloud/nuscenes_conv/nuscenes_converter.py

@@ -1,5 +1,5 @@
 import os
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 
 import supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_helper as helpers
 import supervisely.io.fs as fs
@@ -8,6 +8,7 @@ from supervisely._utils import is_development
 from supervisely.annotation.obj_class import ObjClass
 from supervisely.annotation.tag_meta import TagMeta, TagValueType
 from supervisely.api.api import Api, ApiField
+from supervisely.api.dataset_api import DatasetInfo
 from supervisely.convert.base_converter import AvailablePointcloudConverters
 from supervisely.convert.pointcloud.pointcloud_converter import PointcloudConverter
 from supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_converter import (
@@ -44,7 +45,7 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
 
     def to_supervisely(
         self,
-        scene_sample,
+        scene_sample: helpers.Sample,
         meta: ProjectMeta,
         renamed_classes: dict = {},
         renamed_tags: dict = {},
@@ -74,23 +75,14 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
         obj_classes = []
         for category in nuscenes.category:
             color = nuscenes.colormap[category["name"]]
-            description = category["description"]
-            if len(description) > 255:
-                # * Trim description to fit into 255 characters limit
-                sentences = description.split(".")
-                trimmed_description = ""
-                for sentence in sentences:
-                    if len(trimmed_description) + len(sentence) + 1 > 255:
-                        break
-                    trimmed_description += sentence + "."
-                description = trimmed_description.strip()
+            description = helpers.trim_description(category["description"])
             obj_classes.append(ObjClass(category["name"], Cuboid3d, color, description=description))
 
         self._meta = ProjectMeta(obj_classes, tag_metas)
         meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
 
         dataset_info = api.dataset.get_info_by_id(dataset_id)
-        scene_name_to_dataset = {}
+        scene_name_to_dataset: Dict[str, DatasetInfo] = {}
 
         scene_names = [scene["name"] for scene in nuscenes.scene]
         scene_cnt = len(scene_names)
@@ -123,7 +115,7 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
             sample_token = scene["first_sample_token"]
 
             # * Extract scene's samples
-            scene_samples = []
+            scene_samples: List[helpers.Sample] = []
             for i in range(scene["nbr_samples"]):
                 sample = nuscenes.get("sample", sample_token)
                 lidar_path, boxes, _ = nuscenes.get_sample_data(sample["data"]["LIDAR_TOP"])
@@ -145,17 +137,16 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
                     ]
                     visibility = nuscenes.get("visibility", ann["visibility_token"])["level"]
 
-                    anns.append(
-                        helpers.AnnotationObject(
-                            name,
-                            box,
-                            current_instance_token,
-                            parent_token,
-                            category,
-                            attributes,
-                            visibility,
-                        )
+                    ann = helpers.AnnotationObject(
+                        name=name,
+                        bbox=box,
+                        instance_token=current_instance_token,
+                        parent_token=parent_token,
+                        category=category,
+                        attributes=attributes,
+                        visibility=visibility,
                     )
+                    anns.append(ann)
 
                 # get camera data
                 sample_data = nuscenes.get("sample_data", sample["data"]["LIDAR_TOP"])
@@ -177,7 +168,7 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
                 pcd_ann = self.to_supervisely(sample, meta, renamed_classes, renamed_tags)
 
                 pcd_path = sample.convert_lidar_to_supervisely()
-                pcd_name = fs.get_file_name(pcd_path)
+                pcd_name = fs.get_file_name_with_ext(pcd_path)
                 pcd_meta = {
                     "frame": idx,
                     "vehicle": log["vehicle"],