supervisely 6.73.457__py3-none-any.whl → 6.73.458__py3-none-any.whl

supervisely/__init__.py

@@ -8,6 +8,22 @@ try:
 except TypeError as e:
     __version__ = "development"
 
+
+class _ApiProtoNotAvailable:
+    """Placeholder class that raises an error when accessing any attribute"""
+
+    def __getattr__(self, name):
+        from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+        raise ImportError(f"Cannot access `api_proto.{name}` : " + PROTOBUF_REQUIRED_ERROR)
+
+    def __bool__(self):
+        return False
+
+    def __repr__(self):
+        return "<api_proto: not available - install supervisely[agent] to enable>"
+
+
 from supervisely.sly_logger import (
     logger,
     ServiceType,
@@ -112,7 +128,14 @@ from supervisely.worker_api.chunking import (
     ChunkedFileWriter,
     ChunkedFileReader,
 )
-import supervisely.worker_proto.worker_api_pb2 as api_proto
+
+# Global import of api_proto works only if protobuf is installed and compatible
+# Otherwise, we use a placeholder that raises an error when accessed
+try:
+    import supervisely.worker_proto.worker_api_pb2 as api_proto
+except Exception:
+    api_proto = _ApiProtoNotAvailable()
+
 
 from supervisely.api.api import Api, UserSession, ApiContext
 from supervisely.api import api

supervisely/api/image_api.py

@@ -397,6 +397,9 @@ class ImageInfo(NamedTuple):
     #: Format: "YYYY-MM-DDTHH:MM:SS.sssZ"
     embeddings_updated_at: Optional[str] = None
 
+    #: :class:`int`: :class:`Dataset<supervisely.project.project.Project>` ID in Supervisely.
+    project_id: int = None
+
     # DO NOT DELETE THIS COMMENT
     #! New fields must be added with default values to keep backward compatibility.
 
@@ -476,6 +479,7 @@ class ImageApi(RemoveableBulkModuleApi):
             ApiField.OFFSET_END,
             ApiField.AI_SEARCH_META,
             ApiField.EMBEDDINGS_UPDATED_AT,
+            ApiField.PROJECT_ID,
         ]
 
     @staticmethod

supervisely/api/video/video_annotation_api.py

@@ -236,11 +236,13 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
         dst_project_meta = ProjectMeta.from_json(
             self._api.project.get_meta(dst_dataset_info.project_id)
         )
-        for src_ids_batch, dst_ids_batch in batched(list(zip(src_video_ids, dst_video_ids))):
+        for src_ids_batch, dst_ids_batch in zip(batched(src_video_ids), batched(dst_video_ids)):
             ann_jsons = self.download_bulk(src_dataset_id, src_ids_batch)
             for dst_id, ann_json in zip(dst_ids_batch, ann_jsons):
                 try:
-                    ann = VideoAnnotation.from_json(ann_json, dst_project_meta)
+                    ann = VideoAnnotation.from_json(
+                        ann_json, dst_project_meta, key_id_map=KeyIdMap()
+                    )
                 except Exception as e:
                     raise RuntimeError("Failed to validate Annotation") from e
                 self.append(dst_id, ann)

supervisely/api/video/video_api.py

@@ -5,6 +5,7 @@ import asyncio
 import datetime
 import json
 import os
+import re
 import urllib.parse
 from functools import partial
 from typing import (
@@ -23,7 +24,11 @@ from typing import (
 import aiofiles
 from numerize.numerize import numerize
 from requests import Response
-from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
+from requests_toolbelt import (
+    MultipartDecoder,
+    MultipartEncoder,
+    MultipartEncoderMonitor,
+)
 from tqdm import tqdm
 
 import supervisely.io.fs as sly_fs
@@ -1186,6 +1191,41 @@ class VideoApi(RemoveableBulkModuleApi):
                 if progress_cb is not None:
                     progress_cb(len(chunk))
 
+    def download_frames(
+        self, video_id: int, frames: List[int], paths: List[str], progress_cb=None
+    ) -> None:
+        endpoint = "videos.bulk.download-frame"
+        response: Response = self._api.get(
+            endpoint,
+            params={},
+            data={ApiField.VIDEO_ID: video_id, ApiField.FRAMES: frames},
+            stream=True,
+        )
+        response.raise_for_status()
+
+        files = {frame_n: None for frame_n in frames}
+        file_paths = {frame_n: path for frame_n, path in zip(frames, paths)}
+
+        try:
+            decoder = MultipartDecoder.from_response(response)
+            for part in decoder.parts:
+                content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
+                # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
+                # The regex has 2 capture group: one for the prefix and one for the actual name value.
+                frame_n = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
+                if files[frame_n] is None:
+                    file_path = file_paths[frame_n]
+                    files[frame_n] = open(file_path, "wb")
+                    if progress_cb is not None:
+                        progress_cb(1)
+                f = files[frame_n]
+                f.write(part.content)
+
+        finally:
+            for f in files.values():
+                if f is not None:
+                    f.close()
+
     def download_range_by_id(
         self,
         id: int,

supervisely/app/v1/app_service.py

@@ -1,3 +1,5 @@
+# isort: skip_file
+
 import json
 import os
 import time
@@ -12,7 +14,8 @@ import queue
 import re
 
 from supervisely.worker_api.agent_api import AgentAPI
-from supervisely.worker_proto import worker_api_pb2 as api_proto
+
+# from supervisely.worker_proto import worker_api_pb2 as api_proto # Import moved to methods where needed
 from supervisely.function_wrapper import function_wrapper
 from supervisely._utils import take_with_default
 from supervisely.sly_logger import logger as default_logger
@@ -30,7 +33,6 @@ from supervisely._utils import _remove_sensitive_information
 from supervisely.worker_api.agent_rpc import send_from_memory_generator
 from supervisely.io.fs_cache import FileCache
 
-
 # https://www.roguelynn.com/words/asyncio-we-did-it-wrong/
 
 
@@ -390,6 +392,13 @@ class AppService:
         )
 
     def publish_sync(self, initial_events=None):
+        try:
+            from supervisely.worker_proto import worker_api_pb2 as api_proto
+        except Exception as e:
+            from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+            raise ImportError(PROTOBUF_REQUIRED_ERROR) from e
+
         if initial_events is not None:
             for event_obj in initial_events:
                 event_obj["api_token"] = os.environ[API_TOKEN]
@@ -507,6 +516,13 @@ class AppService:
             self._error = error
 
     def send_response(self, request_id, data):
+        try:
+            from supervisely.worker_proto import worker_api_pb2 as api_proto
+        except Exception as e:
+            from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+            raise ImportError(PROTOBUF_REQUIRED_ERROR) from e
+
         out_bytes = json.dumps(data).encode("utf-8")
         self.api.put_stream_with_data(
             "SendGeneralEventData",

supervisely/app/v1/constants.py

@@ -7,4 +7,10 @@ SHARED_DATA = '/sessions'
 
 STOP_COMMAND = "stop"
 
-IMAGE_ANNOTATION_EVENTS = ["manual_selected_figure_changed"]
+IMAGE_ANNOTATION_EVENTS = ["manual_selected_figure_changed"]
+
+# Error message for missing or incompatible protobuf dependencies
+PROTOBUF_REQUIRED_ERROR = (
+    "protobuf is required for agent/worker/app_v1 functionality. "
+    "Please install supervisely with agent extras: pip install 'supervisely[agent]'"
+)

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/deploy_model/deploy_model.py

@@ -1,10 +1,10 @@
 import datetime
 import tempfile
+import threading
 from pathlib import Path
 from typing import Any, Dict, List, Literal
 
 import pandas as pd
-import yaml
 
 from supervisely._utils import logger
 from supervisely.api.api import Api
@@ -12,8 +12,6 @@ from supervisely.api.app_api import ModuleInfo
 from supervisely.app.widgets.agent_selector.agent_selector import AgentSelector
 from supervisely.app.widgets.button.button import Button
 from supervisely.app.widgets.container.container import Container
-from supervisely.app.widgets.card.card import Card
-from supervisely.app.widgets.model_info.model_info import ModelInfo
 from supervisely.app.widgets.ecosystem_model_selector.ecosystem_model_selector import (
     EcosystemModelSelector,
 )
@@ -23,7 +21,8 @@ from supervisely.app.widgets.experiment_selector.experiment_selector import (
 from supervisely.app.widgets.fast_table.fast_table import FastTable
 from supervisely.app.widgets.field.field import Field
 from supervisely.app.widgets.flexbox.flexbox import Flexbox
-from supervisely.app.widgets.tabs.tabs import Tabs
+from supervisely.app.widgets.model_info.model_info import ModelInfo
+from supervisely.app.widgets.radio_tabs.radio_tabs import RadioTabs
 from supervisely.app.widgets.text.text import Text
 from supervisely.app.widgets.widget import Widget
 from supervisely.io import env
@@ -211,24 +210,31 @@ class DeployModel(Widget):
             return self._layout
 
         def _create_layout(self) -> Container:
-            frameworks = self.deploy_model.get_frameworks()
-            experiment_infos = []
-            for framework_name in frameworks:
-                experiment_infos.extend(
-                    get_experiment_infos(self.api, self.team_id, framework_name=framework_name)
-                )
             self.experiment_table = ExperimentSelector(
-                experiment_infos=experiment_infos,
-                team_id=self.team_id,
                 api=self.api,
+                team_id=self.team_id,
             )
 
             @self.experiment_table.checkpoint_changed
             def _checkpoint_changed(row: ExperimentSelector.ModelRow, checkpoint_value: str):
                 print(f"Checkpoint changed for {row._experiment_info.task_id}: {checkpoint_value}")
 
+            threading.Thread(target=self.refresh_experiments, daemon=True).start()
+
             return self.experiment_table
 
+        def refresh_experiments(self):
+            self.experiment_table.loading = True
+            frameworks = self.deploy_model.get_frameworks()
+            experiment_infos = []
+            for framework_name in frameworks:
+                experiment_infos.extend(
+                    get_experiment_infos(self.api, self.team_id, framework_name=framework_name)
+                )
+
+            self.experiment_table.set_experiment_infos(experiment_infos)
+            self.experiment_table.loading = False
+
         def get_deploy_parameters(self) -> Dict[str, Any]:
             experiment_info = self.experiment_table.get_selected_experiment_info()
             return {
@@ -267,8 +273,8 @@ class DeployModel(Widget):
     MODES = [str(MODE.CONNECT), str(MODE.PRETRAINED), str(MODE.CUSTOM)]
     MODE_TO_CLASS = {
         str(MODE.CONNECT): Connect,
-        str(MODE.PRETRAINED): Pretrained,
         str(MODE.CUSTOM): Custom,
+        str(MODE.PRETRAINED): Pretrained,
     }
 
     def __init__(
@@ -295,6 +301,11 @@ class DeployModel(Widget):
             self.MODE.PRETRAINED: "Pretrained",
             self.MODE.CUSTOM: "Custom",
         }
+        self.modes_descriptions = {
+            self.MODE.CONNECT: "Connect to an already deployed model",
+            self.MODE.PRETRAINED: "Deploy a pretrained model from the ecosystem",
+            self.MODE.CUSTOM: "Deploy a custom model from your experiments",
+        }
 
         # GUI
         self.layout: Widget = None
@@ -444,31 +455,41 @@ class DeployModel(Widget):
 
         self._init_modes(modes)
         _labels = []
+        _descriptions = []
         _contents = []
+        self.statuses_widgets = Container(
+            widgets=[
+                self.sesson_link,
+                self._model_info_container,
+            ],
+            gap=20,
+        )
+        self.statuses_widgets.hide()
         for mode_name, mode in self.modes.items():
             label = self.modes_labels[mode_name]
+            description = self.modes_descriptions[mode_name]
             if mode_name == str(self.MODE.CONNECT):
                 widgets = [
                     mode.layout,
-                    self._model_info_card,
-                    self.connect_stop_buttons,
                     self.status,
-                    self.sesson_link,
+                    self.statuses_widgets,
+                    self.connect_stop_buttons,
                 ]
             else:
                 widgets = [
                     mode.layout,
-                    self._model_info_card,
                     self.select_agent_field,
-                    self.deploy_stop_buttons,
                     self.status,
-                    self.sesson_link,
+                    self.statuses_widgets,
+                    self.deploy_stop_buttons,
                 ]
+
             content = Container(widgets=widgets, gap=20)
             _labels.append(label)
+            _descriptions.append(description)
             _contents.append(content)
 
-        self.tabs = Tabs(labels=_labels, contents=_contents)
+        self.tabs = RadioTabs(titles=_labels, descriptions=_descriptions, contents=_contents)
         if len(self.modes) == 1:
             self.layout = _contents[0]
         else:
@@ -490,7 +511,7 @@ class DeployModel(Widget):
         def _disconnect_button_clicked():
             self.disconnect()
 
-        @self.tabs.click
+        @self.tabs.value_changed
         def _active_tab_changed(tab_name: str):
             self.set_model_message_by_tab(tab_name)
 
@@ -573,6 +594,7 @@ class DeployModel(Widget):
                 f"Model {framework}: {model_name} deployed with session ID {model_api.task_id}."
             )
             self.model_api = model_api
+            self.statuses_widgets.show()
             self.set_model_status("connected")
             self.set_session_info(task_info)
             self.set_model_info(model_api.task_id)
@@ -603,12 +625,14 @@ class DeployModel(Widget):
             self.set_session_info(task_info)
             self.set_model_info(model_api.task_id)
             self.show_stop()
+            self.statuses_widgets.show()
         except Exception as e:
             logger.error(f"Failed to deploy model: {e}", exc_info=True)
             self.set_model_status("error", str(e))
             self.set_session_info(None)
             self.reset_model_info()
             self.show_deploy_button()
+            self.statuses_widgets.hide()
             self.enable_modes()
         else:
             if str(self.MODE.CONNECT) in self.modes:
@@ -634,6 +658,7 @@ class DeployModel(Widget):
         self.enable_modes()
         self.reset_model_info()
         self.show_deploy_button()
+        self.statuses_widgets.hide()
         if str(self.MODE.CONNECT) in self.modes:
             self.modes[str(self.MODE.CONNECT)]._update_sessions()
 
@@ -645,6 +670,7 @@ class DeployModel(Widget):
         self.set_session_info(None)
         self.reset_model_info()
         self.show_deploy_button()
+        self.statuses_widgets.hide()
         self.enable_modes()
 
     def load_from_json(self, data: Dict[str, Any]) -> None:
@@ -690,29 +716,24 @@ class DeployModel(Widget):
             title="Model Info",
             description="Information about the deployed model",
         )
-
-        self._model_info_container = Container([self._model_info_widget_field])
-        self._model_info_container.hide()
         self._model_info_message = Text("Connect to model to see the session information.")
-
-        self._model_info_card = Card(
-            title="Session Info",
-            description="Model parameters and classes",
-            collapsable=True,
-            content=Container([self._model_info_container, self._model_info_message]),
+        self._model_info_container = Container(
+            [self._model_info_widget_field, self._model_info_message], gap=0
         )
-        self._model_info_card.collapse()
+        self._model_info_widget_field.hide()
+
+        self._model_info_container.hide()
 
     def set_model_info(self, session_id):
-        self._model_info_widget.set_model_info(session_id)
+        self._model_info_widget.set_session_id(session_id)
 
         self._model_info_message.hide()
+        self._model_info_widget_field.show()
         self._model_info_container.show()
-        self._model_info_card.uncollapse()
 
     def reset_model_info(self):
-        self._model_info_card.collapse()
         self._model_info_container.hide()
+        self._model_info_widget_field.hide()
         self._model_info_message.show()
 
     def set_model_message_by_tab(self, tab_name: str):
@@ -724,6 +745,6 @@ class DeployModel(Widget):
             self._model_info_message.set(
                 "Deploy model to see the session information.", status="text"
             )
-        self._model_info_card.collapse()
+        self._model_info_widget_field.hide()
 
     # ------------------------------------------------------------ #

supervisely/app/widgets/experiment_selector/experiment_selector.py

@@ -721,6 +721,14 @@ class ExperimentSelector(Widget):
     def enable(self):
         return self.table.enable()
 
+    @property
+    def loading(self):
+        return self.table.loading
+
+    @loading.setter
+    def loading(self, value: bool):
+        self.table.loading = value
+
     def get_json_data(self):
         return {}
 

supervisely/app/widgets/fast_table/fast_table.py

@@ -265,7 +265,9 @@ class FastTable(Widget):
         self._sliced_data = self._slice_table_data(self._sorted_data, actual_page=self._active_page)
         self._parsed_active_data = self._unpack_pandas_table_data(self._sliced_data)
         StateJson().send_changes()
-        DataJson()[self.widget_id]["data"] = self._parsed_active_data["data"]
+        DataJson()[self.widget_id]["data"] = {
+            i: row for i, row in enumerate(self._parsed_active_data["data"])
+        }
         DataJson()[self.widget_id]["total"] = self._rows_total
         DataJson().send_changes()
         StateJson()["reactToChanges"] = True
@@ -295,7 +297,7 @@ class FastTable(Widget):
         :rtype: Dict[str, Any]
         """
         return {
-            "data": self._parsed_active_data["data"],
+            "data": {i: row for i, row in enumerate(self._parsed_active_data["data"])},
             "columns": self._parsed_source_data["columns"],
             "projectMeta": self._project_meta,
             "columnsOptions": self._columns_options,
@@ -307,7 +309,7 @@ class FastTable(Widget):
                 "isRadio": self._is_radio,
                 "isRowSelectable": self._is_selectable,
                 "maxSelectedRows": self._max_selected_rows,
-                "searchPosition": self._search_position
+                "searchPosition": self._search_position,
             },
             "pageSize": self._page_size,
             "showHeader": self._show_header,
@@ -490,7 +492,9 @@ class FastTable(Widget):
             self._sort_column_idx = None
         self._sort_order = sort.get("order", None)
         self._page_size = init_options.pop("pageSize", 10) 
-        DataJson()[self.widget_id]["data"] = self._parsed_active_data["data"]
+        DataJson()[self.widget_id]["data"] = {
+            i: row for i, row in enumerate(self._parsed_active_data["data"])
+        }
         DataJson()[self.widget_id]["columns"] = self._parsed_active_data["columns"]
         DataJson()[self.widget_id]["columnsOptions"] = self._columns_options
         DataJson()[self.widget_id]["options"] = init_options
@@ -519,7 +523,9 @@ class FastTable(Widget):
         self._parsed_active_data = self._unpack_pandas_table_data(self._sliced_data)
         self._parsed_source_data = self._unpack_pandas_table_data(self._source_data)
         self._rows_total = len(self._parsed_source_data["data"])
-        DataJson()[self.widget_id]["data"] = self._parsed_active_data["data"]
+        DataJson()[self.widget_id]["data"] = {
+            i: row for i, row in enumerate(self._parsed_active_data["data"])
+        }
         DataJson()[self.widget_id]["columns"] = self._parsed_active_data["columns"]
         DataJson()[self.widget_id]["total"] = len(self._source_data)
         DataJson().send_changes()
@@ -715,7 +721,29 @@ class FastTable(Widget):
             self._parsed_active_data,
         ) = self._prepare_working_data()
         self._rows_total = len(self._parsed_source_data["data"])
-        DataJson()[self.widget_id]["data"] = self._parsed_active_data["data"]
+        DataJson()[self.widget_id]["data"] = {
+            i: row for i, row in enumerate(self._parsed_active_data["data"])
+        }
+        DataJson()[self.widget_id]["total"] = self._rows_total
+        DataJson().send_changes()
+        self._maybe_update_selected_row()
+
+    def add_rows(self, rows: List):
+        for row in rows:
+            self._validate_table_sizes(row)
+            self._validate_row_values_types(row)
+        self._source_data = pd.concat(
+            [self._source_data, pd.DataFrame(rows, columns=self._source_data.columns)]
+        ).reset_index(drop=True)
+        (
+            self._parsed_source_data,
+            self._sliced_data,
+            self._parsed_active_data,
+        ) = self._prepare_working_data()
+        self._rows_total = len(self._parsed_source_data["data"])
+        DataJson()[self.widget_id]["data"] = {
+            i: row for i, row in enumerate(self._parsed_active_data["data"])
+        }
         DataJson()[self.widget_id]["total"] = self._rows_total
         DataJson().send_changes()
         self._maybe_update_selected_row()
@@ -743,7 +771,9 @@ class FastTable(Widget):
                 self._parsed_active_data,
             ) = self._prepare_working_data()
             self._rows_total = len(self._parsed_source_data["data"])
-            DataJson()[self.widget_id]["data"] = self._parsed_active_data["data"]
+            DataJson()[self.widget_id]["data"] = {
+                i: row for i, row in enumerate(self._parsed_active_data["data"])
+            }
             DataJson()[self.widget_id]["total"] = self._rows_total
             self._maybe_update_selected_row()
             return popped_row
@@ -755,7 +785,7 @@ class FastTable(Widget):
         self._sliced_data = pd.DataFrame(columns=self._columns_first_idx)
         self._parsed_active_data = {"data": [], "columns": []}
         self._rows_total = 0
-        DataJson()[self.widget_id]["data"] = []
+        DataJson()[self.widget_id]["data"] = {}
         DataJson()[self.widget_id]["total"] = 0
         DataJson().send_changes()
         self._maybe_update_selected_row()
@@ -925,7 +955,9 @@ class FastTable(Widget):
         self._sorted_data = self._sort_table_data(self._searched_data)
         self._sliced_data = self._slice_table_data(self._sorted_data, actual_page=self._active_page)
         self._parsed_active_data = self._unpack_pandas_table_data(self._sliced_data)
-        DataJson()[self.widget_id]["data"] = self._parsed_active_data["data"]
+        DataJson()[self.widget_id]["data"] = {
+            i: row for i, row in enumerate(self._parsed_active_data["data"])
+        }
         DataJson()[self.widget_id]["total"] = self._rows_total
         self._maybe_update_selected_row()
         StateJson().send_changes()
@@ -1206,7 +1238,9 @@ class FastTable(Widget):
 
         self._sliced_data = self._slice_table_data(self._sorted_data, actual_page=self._active_page)
         self._parsed_active_data = self._unpack_pandas_table_data(self._sliced_data)
-        DataJson()[self.widget_id]["data"] = self._parsed_active_data["data"]
+        DataJson()[self.widget_id]["data"] = {
+            i: row for i, row in enumerate(self._parsed_active_data["data"])
+        }
         DataJson()[self.widget_id]["total"] = self._rows_total
         DataJson().send_changes()
         StateJson().send_changes()
@@ -1335,4 +1369,4 @@ class FastTable(Widget):
             else:
                 raise TypeError(f"Column name must be a string or a tuple, got {type(col)}")
 
-        self._validate_sort_attrs()
+        self._validate_sort_attrs()

supervisely/app/widgets/fast_table/template.html

@@ -11,7 +11,7 @@
   :project-meta="data.{{{widget.widget_id}}}.projectMeta"
   :sort.sync="state.{{{widget.widget_id}}}.sort"
   :search.sync="state.{{{widget.widget_id}}}.search"
-  :data="data.{{{widget.widget_id}}}.data"
+  :data="Object.values(data.{{{widget.widget_id}}}.data || [])"
   :show-header="data.{{{widget.widget_id}}}.showHeader"
   :selected-rows="state.{{{widget.widget_id}}}.selectedRows"
   :selected-radio-idx="state.{{{widget.widget_id}}}.selectedRows && state.{{{widget.widget_id}}}.selectedRows.length > 0 ? state.{{{widget.widget_id}}}.selectedRows[0].idx : null"

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"