supervisely 6.73.444__py3-none-any.whl → 6.73.468__py3-none-any.whl

supervisely/app/fastapi/subapp.py

@@ -1,23 +1,25 @@
+import hashlib
 import inspect
 import json
 import os
 import signal
 import sys
 import time
-from contextlib import suppress
+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,
@@ -32,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,
@@ -68,6 +71,10 @@ 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):
         if "/readyz" in record.getMessage() or "/livez" in record.getMessage():
@@ -623,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"
@@ -813,41 +832,59 @@ def _init(
     async def get_state_from_request(request: Request, call_next):
         # Start timer for response time measurement
         start_time = time.perf_counter()
-        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
 
-        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)
+        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
+                )
+
+            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)
@@ -1277,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/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/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/dialog/dialog.py

@@ -28,6 +28,8 @@ class Dialog(Widget):
         dialog = Dialog(title="Dialog title", content=Input("Input"), size="large")
         dialog.show()
     """
+    class Routes:
+        ON_CLOSE = "close_cb"
 
     def __init__(
         self,
@@ -41,6 +43,16 @@ class Dialog(Widget):
         self._size = size
         super().__init__(widget_id=widget_id, file_path=__file__)
 
+        server = self._sly_app.get_server()
+        route = self.get_route_path(Dialog.Routes.ON_CLOSE)
+        @server.post(route)
+        def _on_close():
+            # * Change visibility state to False when dialog is closed on client side
+            visible = StateJson()[self.widget_id]["visible"]
+            if visible is True:
+                StateJson()[self.widget_id]["visible"] = False
+                # * no need to call send_changes(), as it is already changed on client side
+
     def get_json_data(self) -> Dict[str, str]:
         """Returns dictionary with widget data, which defines the appearance and behavior of the widget.