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

supervisely/app/widgets/select_user/select_user.py

@@ -0,0 +1,270 @@
+from typing import Callable, List, Optional, Union
+
+from supervisely.api.user_api import UserInfo
+from supervisely.app import DataJson, StateJson
+from supervisely.app.widgets import Widget
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+
+class SelectUser(Widget):
+    """
+    SelectUser is a dropdown widget for selecting users from a team.
+    Extends the Select widget with user-specific functionality.
+
+    :param users: Initial list of UserInfo instances
+    :type users: Optional[List[UserInfo]]
+    :param team_id: Team ID to fetch users from
+    :type team_id: Optional[int]
+    :param roles: List of allowed user roles to filter by (e.g., ['admin', 'developer'])
+    :type roles: Optional[List[str]]
+    :param filterable: Enable search/filter functionality in dropdown
+    :type filterable: Optional[bool]
+    :param placeholder: Placeholder text when no user is selected
+    :type placeholder: Optional[str]
+    :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 SelectUser
+
+        # Initialize with team_id and filter by roles
+        select_user = SelectUser(
+            team_id=123,
+            roles=['admin', 'developer'],
+            multiple=True
+        )
+
+        # Or initialize empty and set users later
+        select_user = SelectUser(roles=['annotator', 'reviewer'])
+        select_user.set_users(user_list)
+
+        # Handle selection changes
+        @select_user.value_changed
+        def on_user_selected(users):
+            if isinstance(users, list):
+                print(f"Selected users: {[u.login for u in users]}")
+            else:
+                print(f"Selected user: {users.login}")
+    """
+
+    class Routes:
+        VALUE_CHANGED = "value_changed"
+
+    def __init__(
+        self,
+        users: Optional[List[UserInfo]] = None,
+        team_id: Optional[int] = None,
+        roles: Optional[List[str]] = None,
+        filterable: Optional[bool] = True,
+        placeholder: Optional[str] = "Select user",
+        size: Optional[Literal["large", "small", "mini"]] = None,
+        multiple: bool = False,
+        widget_id: Optional[str] = None,
+    ):
+        self._users = []
+        self._team_id = team_id
+        self._allowed_roles = roles
+        self._filterable = filterable
+        self._placeholder = placeholder
+        self._size = size
+        self._multiple = multiple
+        self._changes_handled = False
+
+        # Load users from team_id if provided
+        if team_id is not None:
+            self._load_users_from_team(team_id)
+        elif users is not None:
+            self._users = self._filter_users_by_role(list(users))
+
+        # Initialize parent Widget
+        super().__init__(widget_id=widget_id, file_path=__file__)
+
+    def _filter_users_by_role(self, users: List[UserInfo]) -> List[UserInfo]:
+        """Filter users by allowed roles."""
+        if self._allowed_roles is None:
+            return users
+
+        return [user for user in users if user.role in self._allowed_roles]
+
+    def _load_users_from_team(self, team_id: int):
+        """Load users from a team using the API."""
+        from supervisely import Api
+
+        api = Api.from_env()
+        all_users = api.user.get_team_members(team_id)
+        self._users = self._filter_users_by_role(all_users)
+
+    def get_json_data(self):
+        """Build JSON data for the widget."""
+        items = []
+        for user in self._users:
+            user_name = None
+            if user.name:
+                name = user.name.strip()
+                if name:
+                    user_name = name[:15] + "…" if len(name) > 15 else name
+
+            right_text = ""
+            user_role = user.role.upper() if user.role else "NONE"
+            if len(user_role) > 10:
+                user_role = user_role[:10] + "…"
+            if user_name and user_name != user.login:
+                right_text = f"{user_name} • {user_role}"
+            else:
+                right_text = user_role
+
+            items.append(
+                {
+                    "value": user.login,
+                    "label": user.login,
+                    "rightText": right_text,
+                }
+            )
+
+        return {
+            "items": items,
+            "placeholder": self._placeholder,
+            "filterable": self._filterable,
+            "multiple": self._multiple,
+            "size": self._size,
+        }
+
+    def get_json_state(self):
+        """Build JSON state for the widget."""
+        value = None
+        if self._multiple:
+            value = []
+        return {"value": value}
+
+    def get_value(self) -> Union[str, List[str], None]:
+        """Get the currently selected user login(s)."""
+        return StateJson()[self.widget_id]["value"]
+
+    def get_selected_user(self) -> Union[UserInfo, List[UserInfo], None]:
+        """Get the currently selected UserInfo object(s)."""
+        value = self.get_value()
+        if value is None:
+            return None
+
+        if self._multiple:
+            if not isinstance(value, list):
+                return []
+            result = []
+            for login in value:
+                for user in self._users:
+                    if user.login == login:
+                        result.append(user)
+                        break
+            return result
+        else:
+            for user in self._users:
+                if user.login == value:
+                    return user
+            return None
+
+    def set_value(self, login: Union[str, List[str]]):
+        """Set the selected user by login."""
+        StateJson()[self.widget_id]["value"] = login
+        StateJson().send_changes()
+
+    def get_all_users(self) -> List[UserInfo]:
+        """Get all available users."""
+        return self._users.copy()
+
+    def set_users(self, users: List[UserInfo]):
+        """Update the list of available users."""
+        self._users = self._filter_users_by_role(list(users))
+
+        # Update data
+        DataJson()[self.widget_id] = self.get_json_data()
+        DataJson().send_changes()
+
+        # Reset value if current selection is not in new users
+        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(u.login == v for u in self._users)]
+                    if valid != current_value:
+                        StateJson()[self.widget_id]["value"] = valid
+                        StateJson().send_changes()
+            else:
+                if not any(u.login == current_value for u in self._users):
+                    StateJson()[self.widget_id]["value"] = (
+                        self._users[0].login if self._users else None
+                    )
+                    StateJson().send_changes()
+
+    def set_team_id(self, team_id: int):
+        """Load users from a team by team_id."""
+        self._team_id = team_id
+        self._load_users_from_team(team_id)
+
+        # Update data
+        DataJson()[self.widget_id] = self.get_json_data()
+        DataJson().send_changes()
+
+        # Reset selection
+        if self._multiple:
+            StateJson()[self.widget_id]["value"] = []
+        else:
+            StateJson()[self.widget_id]["value"] = self._users[0].login if self._users else None
+        StateJson().send_changes()
+
+    def set_selected_users_by_ids(self, user_ids: Union[int, List[int]]):
+        """Set the selected user(s) by user ID(s).
+
+        :param user_ids: Single user ID or list of user IDs to select
+        :type user_ids: Union[int, List[int]]
+        """
+        if isinstance(user_ids, int):
+            user_ids = [user_ids]
+
+        # Find logins for the given user IDs
+        selected_logins = []
+        for user_id in user_ids:
+            for user in self._users:
+                if user.id == user_id:
+                    selected_logins.append(user.login)
+                    break
+
+        # Set value based on multiple mode
+        if self._multiple:
+            StateJson()[self.widget_id]["value"] = selected_logins
+        else:
+            StateJson()[self.widget_id]["value"] = selected_logins[0] if selected_logins else None
+
+        StateJson().send_changes()
+
+    def value_changed(self, func: Callable[[Union[UserInfo, List[UserInfo]]], None]):
+        """
+        Decorator to handle value change event.
+        The decorated function receives the selected UserInfo (or list of UserInfo if multiple=True).
+
+        :param func: Function to be called when selection changes
+        :type func: Callable[[Union[UserInfo, List[UserInfo]]], None]
+        """
+        route_path = self.get_route_path(SelectUser.Routes.VALUE_CHANGED)
+        server = self._sly_app.get_server()
+        self._changes_handled = True
+
+        @server.post(route_path)
+        def _value_changed():
+            selected = self.get_selected_user()
+            if selected is not None:
+                func(selected)
+
+        return _value_changed

supervisely/app/widgets/select_user/template.html

@@ -0,0 +1,13 @@
+<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" style="font-size: 12px;">
+		<i class="zmdi zmdi-account" style="margin-right: 8px;"></i>
+		{{ item.label }}
+		<span v-if="item.rightText" style="float: right; color: #8492a6; font-size: 12px; margin-right: 20px; margin-left: 10px;">
+			{{ item.rightText }}
+		</span>
+	</el-option>
+</el-select>

supervisely/app/widgets/select_workspace/select_workspace.py

@@ -1,18 +1,20 @@
-from typing import Dict
+from typing import Callable, Dict
 
 try:
     from typing import Literal
 except ImportError:
     from typing_extensions import Literal
 
-from supervisely.app import DataJson, StateJson
-from supervisely.app.widgets import Widget, SelectTeam, generate_id
 from supervisely.api.api import Api
-from supervisely.sly_logger import logger
+from supervisely.app import DataJson, StateJson
+from supervisely.app.widgets import SelectTeam, Widget, generate_id
 from supervisely.app.widgets.select_sly_utils import _get_int_or_env
 
 
 class SelectWorkspace(Widget):
+    class Routes:
+        VALUE_CHANGED = "value_changed"
+
     def __init__(
         self,
         default_id: int = None,
@@ -30,20 +32,18 @@ class SelectWorkspace(Widget):
         self._size = size
         self._team_selector = None
         self._disabled = False
+        self._changes_handled = False
 
         self._default_id = _get_int_or_env(self._default_id, "context.workspaceId")
         if self._default_id is not None:
-            info = self._api.workspace.get_info_by_id(
-                self._default_id, raise_error=True
-            )
+            info = self._api.workspace.get_info_by_id(self._default_id, raise_error=True)
             self._team_id = info.team_id
         self._team_id = _get_int_or_env(self._team_id, "context.teamId")
 
         if compact is True:
+            # If team_id is not provided in compact mode, start disabled
             if self._team_id is None:
-                raise ValueError(
-                    '"team_id" have to be passed as argument or "compact" has to be False'
-                )
+                self._disabled = True
         else:
             # if self._show_label is False:
             #     logger.warn(
@@ -74,6 +74,35 @@ class SelectWorkspace(Widget):
             res["options"]["size"] = self._size
         return res
 
+    def get_team_id(self):
+        if self._compact is True:
+            return self._team_id
+        else:
+            return self._team_selector.get_selected_id()
+
+    def set_team_id(self, team_id: int):
+        """Set the team ID and update the UI. Automatically enables the widget if it was disabled."""
+        self._team_id = team_id
+        if self._compact is False and self._team_selector is not None:
+            self._team_selector.set_team_id(team_id)
+        else:
+            DataJson()[self.widget_id]["teamId"] = team_id
+            DataJson().send_changes()
+
+        # Auto-enable the widget when team_id is set
+        if self._disabled and team_id is not None:
+            self.enable()
+
+    def set_workspace_id(self, workspace_id: int):
+        """Set the workspace ID and update the UI."""
+        StateJson()[self.widget_id]["workspaceId"] = workspace_id
+        StateJson().send_changes()
+
+    def set_ids(self, team_id: int, workspace_id: int):
+        """Set both team ID and workspace ID and update the UI."""
+        self.set_team_id(team_id)
+        self.set_workspace_id(workspace_id)
+
     def get_json_state(self) -> Dict:
         return {
             "workspaceId": self._default_id,
@@ -95,3 +124,23 @@ class SelectWorkspace(Widget):
         self._disabled = False
         DataJson()[self.widget_id]["disabled"] = self._disabled
         DataJson().send_changes()
+
+    def value_changed(self, func: Callable[[int], None]):
+        """
+        Decorator to handle workspace selection change event.
+        The decorated function receives the selected workspace ID.
+
+        :param func: Function to be called when workspace selection changes
+        :type func: Callable[[int], None]
+        """
+        route_path = self.get_route_path(SelectWorkspace.Routes.VALUE_CHANGED)
+        server = self._sly_app.get_server()
+        self._changes_handled = True
+
+        @server.post(route_path)
+        def _value_changed():
+            workspace_id = self.get_selected_id()
+            if workspace_id is not None:
+                func(workspace_id)
+
+        return _value_changed

supervisely/app/widgets/select_workspace/template.html

@@ -1,15 +1,12 @@
 <div>
   {% if widget._compact == false %}
-    {{{widget._team_selector}}}
+  {{{widget._team_selector}}}
   {% endif %}
-  <sly-select-team-workspace
-    {% if widget._compact == false %}
-    :team-id.sync="state.{{{widget._team_selector.widget_id}}}.teamId"
-    {% else %}
-    :team-id.sync="data.{{{widget.widget_id}}}.teamId"
-    {% endif %}
-    :workspace-id.sync="state.{{{widget.widget_id}}}.workspaceId"
-    :options="data.{{{widget.widget_id}}}.options"
-    :disabled="data.{{{widget.widget_id}}}.disabled"
-  ></sly-select-team-workspace>
-</div>
+  <sly-select-team-workspace {% if widget._compact==false %}
+    :team-id.sync="state.{{{widget._team_selector.widget_id}}}.teamId" {% else %}
+    :team-id.sync="data.{{{widget.widget_id}}}.teamId" {% endif %}
+    :workspace-id.sync="state.{{{widget.widget_id}}}.workspaceId" {% if widget._changes_handled==true %}
+    @update:workspace-id="state.{{{widget.widget_id}}}.workspaceId = $event; post('/{{{widget.widget_id}}}/value_changed')"
+    {% endif %} :options="data.{{{widget.widget_id}}}.options"
+    :disabled="data.{{{widget.widget_id}}}.disabled"></sly-select-team-workspace>
+</div>

supervisely/app/widgets/table/table.py

@@ -1,3 +1,5 @@
+# isort: skip_file
+
 import copy
 import io
 
@@ -54,9 +56,8 @@ class PackerUnpacker:
 
     @staticmethod
     def pandas_unpacker(data: pd.DataFrame):
-        data = data.replace({np.nan: None})
-        # data = data.astype(object).replace(np.nan, "-") # TODO: replace None later
-
+        # Keep None/NaN values in source data, don't replace them
+        # They will be converted to "" only when sending to frontend
         unpacked_data = {
             "columns": data.columns.to_list(),
             "data": data.values.tolist(),
@@ -169,9 +170,35 @@ class Table(Widget):
 
         super().__init__(widget_id=widget_id, file_path=__file__)
 
+    def _prepare_data_for_frontend(self, data_dict):
+        """Convert None and NaN values to empty strings for frontend display.
+        This preserves the original None/NaN values in _parsed_data.
+        """
+        import math
+
+        display_data = copy.deepcopy(data_dict)
+
+        # Convert None/NaN in data rows
+        for row in display_data.get("data", []):
+            for i in range(len(row)):
+                value = row[i]
+                # Check for None or NaN (NaN is a float that doesn't equal itself)
+                if value is None or (isinstance(value, float) and math.isnan(value)):
+                    row[i] = ""
+
+        # Convert None/NaN in summary row if present
+        if "summaryRow" in display_data and display_data["summaryRow"] is not None:
+            summary_row = display_data["summaryRow"]
+            for i in range(len(summary_row)):
+                value = summary_row[i]
+                if value is None or (isinstance(value, float) and math.isnan(value)):
+                    summary_row[i] = ""
+
+        return display_data
+
     def get_json_data(self):
         return {
-            "table_data": self._parsed_data,
+            "table_data": self._prepare_data_for_frontend(self._parsed_data),
             "table_options": {
                 "perPage": self._per_page,
                 "pageSizes": self._page_sizes,
@@ -255,13 +282,17 @@ class Table(Widget):
 
     def read_json(self, value: dict) -> None:
         self._update_table_data(input_data=value)
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
         self.clear_selection()
 
     def read_pandas(self, value: pd.DataFrame) -> None:
         self._update_table_data(input_data=value)
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
         self.clear_selection()
 
@@ -272,7 +303,9 @@ class Table(Widget):
         index = len(table_data) if index > len(table_data) or index < 0 else index
 
         self._parsed_data["data"].insert(index, data)
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
 
     def pop_row(self, index=-1):
@@ -284,7 +317,9 @@ class Table(Widget):
 
         if len(self._parsed_data["data"]) != 0:
             popped_row = self._parsed_data["data"].pop(index)
-            DataJson()[self.widget_id]["table_data"] = self._parsed_data
+            DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+                self._parsed_data
+            )
             DataJson().send_changes()
             return popped_row
 
@@ -382,11 +417,27 @@ class Table(Widget):
         StateJson()[self.widget_id]["selected_row"] = {}
         StateJson().send_changes()
 
+    @staticmethod
+    def _values_equal(val1, val2):
+        """Compare two values, handling NaN specially."""
+        import math
+
+        # Check if both are NaN
+        is_nan1 = isinstance(val1, float) and math.isnan(val1)
+        is_nan2 = isinstance(val2, float) and math.isnan(val2)
+        if is_nan1 and is_nan2:
+            return True
+        # Check if both are None
+        if val1 is None and val2 is None:
+            return True
+        # Regular comparison
+        return val1 == val2
+
     def delete_row(self, key_column_name, key_cell_value):
         col_index = self._parsed_data["columns"].index(key_column_name)
         row_indices = []
         for idx, row in enumerate(self._parsed_data["data"]):
-            if row[col_index] == key_cell_value:
+            if self._values_equal(row[col_index], key_cell_value):
                 row_indices.append(idx)
         if len(row_indices) == 0:
             raise ValueError('Column "{key_column_name}" does not have value "{key_cell_value}"')
@@ -400,7 +451,7 @@ class Table(Widget):
         key_col_index = self._parsed_data["columns"].index(key_column_name)
         row_indices = []
         for idx, row in enumerate(self._parsed_data["data"]):
-            if row[key_col_index] == key_cell_value:
+            if self._values_equal(row[key_col_index], key_cell_value):
                 row_indices.append(idx)
         if len(row_indices) == 0:
             raise ValueError('Column "{key_column_name}" does not have value "{key_cell_value}"')
@@ -411,20 +462,24 @@ class Table(Widget):
 
         col_index = self._parsed_data["columns"].index(column_name)
         self._parsed_data["data"][row_indices[0]][col_index] = new_value
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
 
     def update_matching_cells(self, key_column_name, key_cell_value, column_name, new_value):
         key_col_index = self._parsed_data["columns"].index(key_column_name)
         row_indices = []
         for idx, row in enumerate(self._parsed_data["data"]):
-            if row[key_col_index] == key_cell_value:
+            if self._values_equal(row[key_col_index], key_cell_value):
                 row_indices.append(idx)
 
         col_index = self._parsed_data["columns"].index(column_name)
         for row_idx in row_indices:
             self._parsed_data["data"][row_idx][col_index] = new_value
-        DataJson()[self.widget_id]["table_data"] = self._parsed_data
+        DataJson()[self.widget_id]["table_data"] = self._prepare_data_for_frontend(
+            self._parsed_data
+        )
         DataJson().send_changes()
 
     def sort(self, column_id: int = None, direction: Optional[Literal["asc", "desc"]] = None):

supervisely/app/widgets/tree_select/tree_select.py

@@ -264,6 +264,8 @@ class TreeSelect(Widget):
 
         def _get_all_items(items: List[TreeSelect.Item]) -> List[TreeSelect.Item]:
             res = []
+            if not items:
+                return res
             for item in items:
                 res.append(item)
                 res.extend(_get_all_items(item.children))

supervisely/aug/aug.py

@@ -526,7 +526,9 @@ def instance_crop(
 
 
 # Resize
-def resize(img: np.ndarray, ann: Annotation, size: Tuple) -> Tuple[np.ndarray, Annotation]:
+def resize(
+    img: np.ndarray, ann: Annotation, size: Tuple, skip_empty_masks: bool = False
+) -> Tuple[np.ndarray, Annotation]:
     """
     Resizes an input Image and Annotation to a given size.
 
@@ -536,6 +538,8 @@ def resize(img: np.ndarray, ann: Annotation, size: Tuple) -> Tuple[np.ndarray, A
     :type ann: Annotation
     :param size: Desired size (height, width) in pixels or -1.
     :type size: Tuple[int, int]
+    :param skip_empty_masks: If True, skips resizing of empty masks in Annotation.
+    :type skip_empty_masks: bool, optional
     :raises: :class:`RuntimeError` if Image shape does not match img_size in Annotation
     :return: Tuple containing resized Image and Annotation
     :rtype: :class:`Tuple[np.ndarray, Annotation]`
@@ -576,7 +580,7 @@ def resize(img: np.ndarray, ann: Annotation, size: Tuple) -> Tuple[np.ndarray, A
 
     new_size = sly_image.restore_proportional_size(in_size=ann.img_size, out_size=size)
     res_img = sly_image.resize(img, new_size)
-    res_ann = ann.resize(new_size)
+    res_ann = ann.resize(new_size, skip_empty_masks=skip_empty_masks)
     return res_img, res_ann
 
 

supervisely/convert/base_converter.py

@@ -49,6 +49,7 @@ class AvailableVideoConverters:
     SLY = "supervisely"
     MOT = "mot"
     DAVIS = "davis"
+    MULTI_VIEW = "multi_view"
 
 
 class AvailablePointcloudConverters:

supervisely/convert/converter.py

@@ -105,9 +105,9 @@ class ImportManager:
         )
         return modality_converter.detect_format()
 
-    def upload_dataset(self, dataset_id):
+    def upload_dataset(self, dataset_id) -> Optional[int]:
         """Upload converted data to Supervisely"""
-        self.converter.upload_dataset(self._api, dataset_id)
+        return self.converter.upload_dataset(self._api, dataset_id)
 
     # def validate_format(self):
     #     raise NotImplementedError