supervisely 6.73.410__py3-none-any.whl → 6.73.470__py3-none-any.whl

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/app/widgets/radio_table/radio_table.py

@@ -1,6 +1,7 @@
-from typing import List, Dict, Union
-from supervisely.app.jinja2 import create_env
+from typing import Dict, List, Union
+
 from supervisely.app.content import DataJson, StateJson
+from supervisely.app.jinja2 import create_env
 from supervisely.app.widgets import Widget
 
 
@@ -154,3 +155,10 @@ class RadioTable(Widget):
             raise ValueError(f'Row with index "{row_index}" does not exist')
         StateJson()[self.widget_id]["selectedRow"] = row_index
         StateJson().send_changes()
+
+    def select_row_by_value(self, column, value):
+        for idx, row in enumerate(self._rows):
+            if row[self._columns.index(column)] == value:
+                self.select_row(idx)
+                return
+        raise ValueError(f'Value "{value}" not found in column "{column}"')

supervisely/app/widgets/radio_tabs/radio_tabs.py

@@ -1,5 +1,9 @@
-from typing import List, Optional, Dict
+import traceback
+from typing import Dict, List, Optional
+
+from supervisely._utils import logger
 from supervisely.app import StateJson
+from supervisely.app.content import DataJson
 from supervisely.app.widgets import Widget
 
 
@@ -65,7 +69,7 @@ class RadioTabs(Widget):
         return _value_changed
 
     def get_json_data(self) -> Dict:
-        return {}
+        return {"tabsOptions": {item.name: {"disabled": False} for item in self._items}}
 
     def get_json_state(self) -> Dict:
         return {"value": self._value}
@@ -77,3 +81,15 @@ class RadioTabs(Widget):
 
     def get_active_tab(self) -> str:
         return StateJson()[self.widget_id]["value"]
+
+    def disable_tab(self, tab_name: str):
+        if tab_name not in [item.name for item in self._items]:
+            raise ValueError(f"Tab with name '{tab_name}' does not exist.")
+        DataJson()[self.widget_id]["tabsOptions"][tab_name]["disabled"] = True
+        DataJson().send_changes()
+
+    def enable_tab(self, tab_name: str):
+        if tab_name not in [item.name for item in self._items]:
+            raise ValueError(f"Tab with name '{tab_name}' does not exist.")
+        DataJson()[self.widget_id]["tabsOptions"][tab_name]["disabled"] = False
+        DataJson().send_changes()

supervisely/app/widgets/radio_tabs/template.html

@@ -20,6 +20,7 @@
     {% for tab_pane in widget._items %}
     <el-tab-pane
         name="{{{tab_pane.name}}}"
+        :disabled="data.{{{widget.widget_id}}}.tabsOptions['{{{tab_pane.name}}}'].disabled"
     >
         <el-radio 
             slot="label" 

supervisely/app/widgets/select/select.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-from supervisely.app import StateJson, DataJson
-from supervisely.app.widgets import Widget, ConditionalWidget
-from typing import List, Dict, Optional
+
+from typing import Dict, List, Optional
+
+from supervisely.app import DataJson, StateJson
+from supervisely.app.widgets import ConditionalWidget, Widget
 
 try:
     from typing import Literal
@@ -183,7 +185,7 @@ class Select(ConditionalWidget):
         self._changes_handled = True
 
         @server.post(route_path)
-        async def _click():
+        def _click():
             res = self.get_value()
             func(res)
 

supervisely/app/widgets/select_dataset/select_dataset.py

@@ -138,6 +138,12 @@ class SelectDataset(Widget):
 
     def set_project_id(self, id: int):
         self._project_id = id
+        if self._compact is True:
+            DataJson()[self.widget_id]["projectId"] = self._project_id
+            DataJson().send_changes()
+        else:
+            StateJson()[self.widget_id]["projectId"] = self._project_id
+            StateJson().send_changes()
         self._project_selector.set_project_id(self._project_id)
 
     def set_select_all_datasets(self, is_checked: bool):