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

supervisely/app/fastapi/custom_static_files.py

@@ -42,7 +42,7 @@ class CustomStaticFiles(StaticFiles):
         def _get_range_header(range_header: str, file_size: int) -> typing.Tuple[int, int]:
             def _invalid_range():
                 return HTTPException(
-                    status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
+                    status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE, #TODO: change to status.HTTP_416_RANGE_NOT_SATISFIABLE if update starlette to 0.48.0+
                     detail=f"Invalid request range (Range:{range_header!r})",
                 )
 

supervisely/app/fastapi/multi_user.py

@@ -0,0 +1,88 @@
+import hashlib
+from contextlib import contextmanager
+from typing import Optional, Union
+
+from fastapi import Request
+
+import supervisely.io.env as sly_env
+from supervisely.api.module_api import ApiField
+from supervisely.app.fastapi.websocket import WebsocketManager
+from supervisely.sly_logger import logger
+
+
+def _parse_int(value):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _user_identity_from_cookie(request: Request) -> Optional[str]:
+    cookie_header = request.headers.get("cookie")
+    if not cookie_header:
+        return None
+    return hashlib.sha256(cookie_header.encode("utf-8")).hexdigest()
+
+
+async def extract_user_id_from_request(request: Request) -> Optional[Union[int, str]]:
+    """Extract user ID from various parts of the request."""
+    if not sly_env.is_multiuser_mode_enabled():
+        return None
+    user_id = _parse_int(request.query_params.get("userId"))
+    if user_id is None:
+        header_user = _parse_int(request.headers.get("x-user-id"))
+        if header_user is not None:
+            user_id = header_user
+    if user_id is None:
+        referer = request.headers.get("referer", "")
+        if referer:
+            from urllib.parse import parse_qs, urlparse
+
+            try:
+                parsed_url = urlparse(referer)
+                query_params = parse_qs(parsed_url.query)
+                referer_user = query_params.get("userId", [None])[0]
+                user_id = _parse_int(referer_user)
+            except Exception as e:
+                logger.error(f"Error parsing userId from referer: {e}")
+    if user_id is None and "application/json" in request.headers.get("Content-Type", ""):
+        try:
+            payload = await request.json()
+        except Exception:
+            payload = {}
+        context = payload.get("context") or {}
+        user_id = _parse_int(context.get("userId") or context.get(ApiField.USER_ID))
+        if user_id is None:
+            state_payload = payload.get("state") or {}
+            user_id = _parse_int(state_payload.get("userId") or state_payload.get(ApiField.USER_ID))
+    if user_id is None:
+        user_id = _user_identity_from_cookie(request)
+    return user_id
+
+
+@contextmanager
+def session_context(user_id: Optional[Union[int, str]]):
+    """
+    Context manager to set and reset user context for multiuser applications.
+    Call this at the beginning of a request handling to ensure the correct user context is set in environment variables (`supervisely_multiuser_app_user_id` ContextVar).
+    """
+    if not sly_env.is_multiuser_mode_enabled() or user_id is None:
+        yield
+        return
+    token = sly_env.set_user_for_multiuser_app(user_id)
+    try:
+        yield
+    finally:
+        sly_env.reset_user_for_multiuser_app(token)
+
+
+def remember_cookie(request: Request, user_id: Optional[Union[int, str]]):
+    """
+    Remember user cookie for the given user ID. This is used to associate WebSocket connections with users in multiuser applications based on cookies.
+    Allows WebSocket connections to be correctly routed to the appropriate user.
+    """
+    if not sly_env.is_multiuser_mode_enabled() or user_id is None:
+        return
+    cookie_header = request.headers.get("cookie")
+    if cookie_header:
+        WebsocketManager().remember_user_cookie(cookie_header, user_id)

supervisely/app/fastapi/subapp.py

@@ -1,21 +1,25 @@
+import hashlib
 import inspect
 import json
 import os
 import signal
 import sys
-from contextlib import suppress
+import time
+from contextlib import contextmanager, suppress
+from contextvars import ContextVar
 from functools import wraps
 from pathlib import Path
 from threading import Event as ThreadingEvent
 from threading import Thread
 from time import sleep
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
 
 import arel
 import jinja2
 import numpy as np
 import psutil
 from async_asgi_testclient import TestClient
+from cachetools import TTLCache
 from fastapi import (
     Depends,
     FastAPI,
@@ -30,6 +34,7 @@ from fastapi.responses import JSONResponse
 from fastapi.routing import APIRouter
 from fastapi.staticfiles import StaticFiles
 
+import supervisely.app.fastapi.multi_user as multi_user
 import supervisely.io.env as sly_env
 from supervisely._utils import (
     is_debug_with_sly_net,
@@ -61,6 +66,14 @@ SUPERVISELY_SERVER_PATH_PREFIX = sly_env.supervisely_server_path_prefix()
 if SUPERVISELY_SERVER_PATH_PREFIX and not SUPERVISELY_SERVER_PATH_PREFIX.startswith("/"):
     SUPERVISELY_SERVER_PATH_PREFIX = f"/{SUPERVISELY_SERVER_PATH_PREFIX}"
 
+HEALTH_ENDPOINTS = ["/health", "/is_ready"]
+
+# Context variable for response time
+response_time_ctx: ContextVar[float] = ContextVar("response_time", default=None)
+
+# Mapping from user_id to Api instance
+_USER_API_CACHE = TTLCache(maxsize=500, ttl=60 * 15)  # Cache up to 15 minutes
+
 
 class ReadyzFilter(logging.Filter):
     def filter(self, record):
@@ -70,11 +83,22 @@ class ReadyzFilter(logging.Filter):
         return True
 
 
+class ResponseTimeFilter(logging.Filter):
+    def filter(self, record):
+        # Check if this is an HTTP access log line by logger name
+        if getattr(record, "name", "") == "uvicorn.access":
+            response_time = response_time_ctx.get(None)
+            if response_time is not None:
+                record.responseTime = int(response_time)
+        return True
+
+
 def _init_uvicorn_logger():
     uvicorn_logger = logging.getLogger("uvicorn.access")
     for handler in uvicorn_logger.handlers:
         handler.setFormatter(create_formatter())
     uvicorn_logger.addFilter(ReadyzFilter())
+    uvicorn_logger.addFilter(ResponseTimeFilter())
 
 
 _init_uvicorn_logger()
@@ -606,18 +630,30 @@ def create(
         shutdown(process_id, before_shutdown_callbacks)
 
     if headless is False:
-
         @app.post("/data")
         async def send_data(request: Request):
-            data = DataJson()
-            response = JSONResponse(content=dict(data))
+            if not sly_env.is_multiuser_mode_enabled():
+                data = DataJson()
+                response = JSONResponse(content=dict(data))
+                return response
+            user_id = await multi_user.extract_user_id_from_request(request)
+            multi_user.remember_cookie(request, user_id)
+            with multi_user.session_context(user_id):
+                data = DataJson()
+                response = JSONResponse(content=dict(data))
             return response
 
         @app.post("/state")
         async def send_state(request: Request):
-            state = StateJson()
-
-            response = JSONResponse(content=dict(state))
+            if not sly_env.is_multiuser_mode_enabled():
+                state = StateJson()
+                response = JSONResponse(content=dict(state))
+            else:
+                user_id = await multi_user.extract_user_id_from_request(request)
+                multi_user.remember_cookie(request, user_id)
+                with multi_user.session_context(user_id):
+                    state = StateJson()
+                    response = JSONResponse(content=dict(state))
             gettrace = getattr(sys, "gettrace", None)
             if (gettrace is not None and gettrace()) or is_development():
                 response.headers["x-debug-mode"] = "1"
@@ -794,41 +830,64 @@ def _init(
 
     @app.middleware("http")
     async def get_state_from_request(request: Request, call_next):
-        if headless is False:
-            await StateJson.from_request(request)
-
-        if not ("application/json" not in request.headers.get("Content-Type", "")):
-            # {'command': 'inference_batch_ids', 'context': {}, 'state': {'dataset_id': 49711, 'batch_ids': [3120204], 'settings': None}, 'user_api_key': 'XXX', 'api_token': 'XXX', 'instance_type': None, 'server_address': 'https://app.supervisely.com'}
-            content = await request.json()
-
-            request.state.context = content.get("context")
-            request.state.state = content.get("state")
-            request.state.api_token = content.get(
-                "api_token",
-                (
-                    request.state.context.get("apiToken")
-                    if request.state.context is not None
-                    else None
-                ),
-            )
-            # logger.debug(f"middleware request api_token {request.state.api_token}")
-            request.state.server_address = content.get(
-                "server_address", sly_env.server_address(raise_not_found=False)
-            )
-            # request.state.server_address = sly_env.server_address(raise_not_found=False)
-            # logger.debug(f"middleware request server_address {request.state.server_address}")
-            # logger.debug(f"middleware request context {request.state.context}")
-            # logger.debug(f"middleware request state {request.state.state}")
-            if request.state.server_address is not None and request.state.api_token is not None:
-                request.state.api = Api(request.state.server_address, request.state.api_token)
-            else:
-                request.state.api = None
+        # Start timer for response time measurement
+        start_time = time.perf_counter()
+
+        async def _process_request(request: Request, call_next):
+            if "application/json" in request.headers.get("Content-Type", ""):
+                content = await request.json()
+                request.state.context = content.get("context")
+                request.state.state = content.get("state")
+                request.state.api_token = content.get(
+                    "api_token",
+                    (
+                        request.state.context.get("apiToken")
+                        if request.state.context is not None
+                        else None
+                    ),
+                )
+                request.state.server_address = content.get(
+                    "server_address", sly_env.server_address(raise_not_found=False)
+                )
+                if (
+                    request.state.server_address is not None
+                    and request.state.api_token is not None
+                ):
+                    request.state.api = Api(
+                        request.state.server_address, request.state.api_token
+                    )
+                    if sly_env.is_multiuser_mode_enabled():
+                        user_id = sly_env.user_from_multiuser_app()
+                        if user_id is not None:
+                            _USER_API_CACHE[user_id] = request.state.api
+                else:
+                    request.state.api = None
 
-        try:
-            response = await call_next(request)
-        except Exception as exc:
-            need_to_handle_error = is_production()
-            response = await process_server_error(request, exc, need_to_handle_error)
+            try:
+                response = await call_next(request)
+            except Exception as exc:
+                need_to_handle_error = is_production()
+                response = await process_server_error(
+                    request, exc, need_to_handle_error
+                )
+
+            return response
+
+        if not sly_env.is_multiuser_mode_enabled():
+            if headless is False:
+                await StateJson.from_request(request)
+            response = await _process_request(request, call_next)
+        else:
+            user_id = await multi_user.extract_user_id_from_request(request)
+            multi_user.remember_cookie(request, user_id)
+
+            with multi_user.session_context(user_id):
+                if headless is False:
+                    await StateJson.from_request(request, local=False)
+                response = await _process_request(request, call_next)
+        # Calculate response time and set it for uvicorn logger in ms
+        elapsed_ms = round((time.perf_counter() - start_time) * 1000)
+        response_time_ctx.set(elapsed_ms)
         return response
 
     def verify_localhost(request: Request):
@@ -905,7 +964,33 @@ class Application(metaclass=Singleton):
             Callable
         ] = None,  # function to check if the app is ready for requests (e.g serving app: model is served and ready)
         show_header: bool = True,
+        hide_health_check_logs: bool = True,  # whether to hide health check logs in info level
+        health_check_endpoints: Optional[List[str]] = None,  # endpoints to check health of the app
     ):
+        """Initialize the Supervisely Application.
+
+        :param layout: Main layout of the application.
+        :type layout: Widget
+        :param templates_dir: Directory with Jinja2 templates. It is preferred to use `layout` instead of `templates_dir`.
+        :type templates_dir: str, optional
+        :param static_dir: Directory with static files (e.g. CSS, JS), used for serving static content.
+        :type static_dir: str, optional
+        :param hot_reload: Whether to enable hot reload during development (default is False).
+        :type hot_reload: bool, optional
+        :param session_info_extra_content: Additional content to be displayed in the session info area.
+        :type session_info_extra_content: Widget, optional
+        :param session_info_solid: Whether to use solid background for the session info area.
+        :type session_info_solid: bool, optional
+        :param ready_check_function: Function to check if the app is ready for requests.
+        :type ready_check_function: Callable, optional
+        :param show_header: Whether to show the header in the application.
+        :type show_header: bool, optional
+        :param hide_health_check_logs: Whether to hide health check logs in info level.
+        :type hide_health_check_logs: bool, optional
+        :param health_check_endpoints: List of additional endpoints to check health of the app.
+            Add your custom endpoints here to be able to manage logging of health check requests on info level with `hide_health_check_logs`.
+        :type health_check_endpoints: List[str], optional
+        """
         self._favicon = os.environ.get("icon", "https://cdn.supervisely.com/favicon.ico")
         JinjaWidgets().context["__favicon__"] = self._favicon
         JinjaWidgets().context["__no_html_mode__"] = True
@@ -980,6 +1065,17 @@ class Application(metaclass=Singleton):
             hot_reload=hot_reload,
             before_shutdown_callbacks=self._before_shutdown_callbacks,
         )
+
+        # add filter to hide health check logs for info level
+        if health_check_endpoints is None or len(health_check_endpoints) == 0:
+            self._health_check_endpoints = HEALTH_ENDPOINTS
+        else:
+            health_check_endpoints = [endpoint.strip() for endpoint in health_check_endpoints]
+            self._health_check_endpoints = HEALTH_ENDPOINTS + health_check_endpoints
+
+        if hide_health_check_logs:
+            self._setup_health_check_filter()
+
         self.test_client = TestClient(self._fastapi)
 
         if not headless:
@@ -1126,6 +1222,34 @@ class Application(metaclass=Singleton):
     def set_ready_check_function(self, func: Callable):
         self._ready_check_function = func
 
+    def _setup_health_check_filter(self):
+        """Setup filter to hide health check logs for info level."""
+
+        class HealthCheckFilter(logging.Filter):
+            def __init__(self, app_instance):
+                super().__init__()
+                self.app: Application = app_instance
+
+            def filter(self, record):
+                # Hide health check requests if NOT in debug mode
+                if not self.app._fastapi.debug and hasattr(record, "getMessage"):
+                    message = record.getMessage()
+                    # Check if the message contains health check paths
+                    if any(path in message for path in self.app._health_check_endpoints):
+                        return False
+                return True
+
+        # Apply filter to uvicorn access logger
+        health_filter = HealthCheckFilter(self)
+        uvicorn_logger = logging.getLogger("uvicorn.access")
+
+        # Remove old filters of this type, if any (for safety)
+        uvicorn_logger.filters = [
+            f for f in uvicorn_logger.filters if not isinstance(f, HealthCheckFilter)
+        ]
+
+        uvicorn_logger.addFilter(health_filter)
+
 
 def set_autostart_flag_from_state(default: Optional[str] = None):
     """Set `autostart` flag recieved from task state. Env name: `modal.state.autostart`.
@@ -1190,3 +1314,12 @@ def call_on_autostart(
 
 def get_name_from_env(default="Supervisely App"):
     return os.environ.get("APP_NAME", default)
+
+def session_user_api() -> Optional[Api]:
+    """Returns the API instance for the current session user."""
+    if not sly_env.is_multiuser_mode_enabled():
+        return Api.from_env()
+    user_id = sly_env.user_from_multiuser_app()
+    if user_id is None:
+        return None
+    return _USER_API_CACHE.get(user_id, None)

supervisely/app/fastapi/templating.py

@@ -11,7 +11,7 @@ from supervisely.app.singleton import Singleton
 from supervisely.app.widgets_context import JinjaWidgets
 
 # https://github.com/supervisely/js-bundle
-js_bundle_version = "2.1.99"
+js_bundle_version = "2.2.2"
 
 # https://github.com/supervisely-ecosystem/supervisely-app-frontend-js
 js_frontend_version = "v0.0.56"

supervisely/app/fastapi/websocket.py

@@ -1,5 +1,10 @@
-from typing import List
+import hashlib
+import time
+from typing import Dict, List, Optional, Tuple, Union
+
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+import supervisely.io.env as sly_env
 from supervisely.app.singleton import Singleton
 
 
@@ -8,6 +13,9 @@ class WebsocketManager(metaclass=Singleton):
         self.app = None
         self.path = path
         self.active_connections: List[WebSocket] = []
+        self._connection_users: Dict[WebSocket, Optional[Union[int, str]]] = {}
+        self._cookie_user_map: Dict[str, Tuple[Union[int, str], float]] = {}
+        self._cookie_ttl_seconds = 60 * 60
 
     def set_app(self, app: FastAPI):
         if self.app is not None:
@@ -17,17 +25,42 @@ class WebsocketManager(metaclass=Singleton):
 
     async def connect(self, websocket: WebSocket):
         await websocket.accept()
+        user_id = self._resolve_user_id(websocket)
         self.active_connections.append(websocket)
+        self._connection_users[websocket] = user_id
 
     def disconnect(self, websocket: WebSocket):
-        self.active_connections.remove(websocket)
-
-    async def broadcast(self, d: dict):
-        # if self.app is None:
-        #     raise ValueError(
-        #         "WebSocket is not initialized, use Websocket middleware for that"
-        #     )
-        for connection in self.active_connections:
+        if websocket in self.active_connections:
+            self.active_connections.remove(websocket)
+        self._connection_users.pop(websocket, None)
+
+    def remember_user_cookie(
+        self, cookie_header: Optional[str], user_id: Optional[Union[int, str]]
+    ):
+        if cookie_header is None or user_id is None:
+            return
+        fingerprint = self._cookie_fingerprint(cookie_header)
+        if fingerprint is None:
+            return
+        self._purge_cookie_cache()
+        self._cookie_user_map[fingerprint] = (user_id, time.monotonic())
+
+    async def broadcast(self, d: dict, user_id: Optional[Union[int, str]] = None):
+        if sly_env.is_multiuser_mode_enabled():
+            if user_id is None:
+                user_id = sly_env.user_from_multiuser_app()
+            if user_id is None:
+                targets = list(self.active_connections)
+            else:
+                targets = [
+                    connection
+                    for connection in self.active_connections
+                    if self._connection_users.get(connection) == user_id
+                ]
+        else:
+            targets = list(self.active_connections)
+
+        for connection in list(targets):
             await connection.send_json(d)
 
     async def endpoint(self, websocket: WebSocket):
@@ -37,3 +70,38 @@ class WebsocketManager(metaclass=Singleton):
                 data = await websocket.receive_text()
         except WebSocketDisconnect:
             self.disconnect(websocket)
+
+    def _resolve_user_id(self, websocket: WebSocket) -> Optional[int]:
+        if not sly_env.is_multiuser_mode_enabled():
+            return None
+        query_user = websocket.query_params.get("userId")
+        if query_user is not None:
+            try:
+                return int(query_user)
+            except ValueError:
+                pass
+        fingerprint = self._cookie_fingerprint(websocket.headers.get("cookie"))
+        if fingerprint is None:
+            return None
+        cached = self._cookie_user_map.get(fingerprint)
+        if cached is None:
+            return None
+        user_id, ts = cached
+        if time.monotonic() - ts > self._cookie_ttl_seconds:
+            self._cookie_user_map.pop(fingerprint, None)
+            return None
+        return user_id
+
+    @staticmethod
+    def _cookie_fingerprint(cookie_header: Optional[str]) -> Optional[str]:
+        if not cookie_header:
+            return None
+        return hashlib.sha256(cookie_header.encode("utf-8")).hexdigest()
+
+    def _purge_cookie_cache(self) -> None:
+        if not self._cookie_user_map:
+            return
+        cutoff = time.monotonic() - self._cookie_ttl_seconds
+        expired = [key for key, (_, ts) in self._cookie_user_map.items() if ts < cutoff]
+        for key in expired:
+            self._cookie_user_map.pop(key, None)

supervisely/app/singleton.py

@@ -1,11 +1,32 @@
+import supervisely.io.env as sly_env
+
+
 class Singleton(type):
     _instances = {}
+    _nested_instances = {}
 
     def __call__(cls, *args, **kwargs):
         local = kwargs.pop("__local__", False)
         if local is False:
             if cls not in cls._instances:
                 cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+
+            if sly_env.is_multiuser_mode_enabled():
+                from supervisely.app.content import DataJson, StateJson
+                from copy import deepcopy
+
+                # Initialize nested instances dict once
+                nested_instances = cls._nested_instances.setdefault(cls, {})
+                
+                user_id = sly_env.user_from_multiuser_app()
+                if user_id is not None and cls in (StateJson, DataJson):
+                    if user_id not in nested_instances:
+                        # Create new instance and copy data
+                        instance = super(Singleton, cls).__call__(*args, **kwargs)
+                        instance.update(deepcopy(dict(cls._instances[cls])))
+                        nested_instances[user_id] = instance
+                    
+                    return nested_instances[user_id]
             return cls._instances[cls]
         else:
             return super(Singleton, cls).__call__(*args, **kwargs)

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/__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
@@ -151,4 +152,13 @@ from supervisely.app.widgets.experiment_selector.experiment_selector import Expe
 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.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,
+)
+from supervisely.app.widgets.ecosystem_model_selector.ecosystem_model_selector import (
+    EcosystemModelSelector,
+)
+from supervisely.app.widgets.heatmap.heatmap import Heatmap

supervisely/app/widgets/agent_selector/template.html

@@ -5,6 +5,7 @@
         :group-id="data.{{{ widget.widget_id }}}.teamId" 
         :options="state.{{{ widget.widget_id }}}.options"
 	    :is-community="data.{{{ widget.widget_id }}}.isCommunity" 
+        :disabled="data.{{{ widget.widget_id }}}.disabled"
         {% if widget._changes_handled == true %} 
             @input="state.{{{ widget.widget_id }}}.agentId = $event; post('/{{{ widget.widget_id }}}/value_changed')"
         {% else %}