supervisely 6.73.452__py3-none-any.whl → 6.73.454__py3-none-any.whl

supervisely/app/__init__.py

@@ -1,7 +1,7 @@
 from fastapi import FastAPI
 from supervisely.app.content import StateJson, DataJson
 from supervisely.app.content import get_data_dir, get_synced_data_dir
-from supervisely.app.fastapi.subapp import call_on_autostart
+from supervisely.app.fastapi.subapp import call_on_autostart, session_user_api
 import supervisely.app.fastapi as fastapi
 import supervisely.app.widgets as widgets
 import supervisely.app.development as development

supervisely/app/content.py

@@ -11,6 +11,7 @@ import threading
 import time
 import traceback
 from concurrent.futures import ThreadPoolExecutor
+from typing import Optional, Union
 
 import jsonpatch
 from fastapi import Request
@@ -109,16 +110,22 @@ class _PatchableJson(dict):
             patch.apply(self._last, in_place=True)
             self._last = copy.deepcopy(self._last)
 
-    async def synchronize_changes(self):
+    async def synchronize_changes(self, user_id: Optional[Union[int, str]] = None):
         patch = self._get_patch()
         await self._apply_patch(patch)
-        await self._ws.broadcast(self.get_changes(patch))
+        await self._ws.broadcast(self.get_changes(patch), user_id=user_id)
 
     async def send_changes_async(self):
-        await self.synchronize_changes()
+        user_id = None
+        if sly_env.is_multiuser_mode_enabled():
+            user_id = sly_env.user_from_multiuser_app()
+        await self.synchronize_changes(user_id=user_id)
 
     def send_changes(self):
-        run_sync(self.synchronize_changes())
+        user_id = None
+        if sly_env.is_multiuser_mode_enabled():
+            user_id = sly_env.user_from_multiuser_app()
+        run_sync(self.synchronize_changes(user_id=user_id))
 
     def raise_for_key(self, key: str):
         if key in self:
@@ -139,7 +146,7 @@ class StateJson(_PatchableJson, metaclass=Singleton):
         await StateJson._replace_global(dict(self))
 
     @classmethod
-    async def from_request(cls, request: Request) -> StateJson:
+    async def from_request(cls, request: Request, local: bool = True) -> StateJson:
         if "application/json" not in request.headers.get("Content-Type", ""):
             return None
         content = await request.json()
@@ -149,7 +156,8 @@ class StateJson(_PatchableJson, metaclass=Singleton):
         # TODO: should we always replace STATE with {}?
         d = content.get(Field.STATE, {})
         await cls._replace_global(d)
-        return cls(d, __local__=True)
+
+        return cls(d, __local__=local)
 
     @classmethod
     async def _replace_global(cls, d: dict):

supervisely/app/fastapi/__init__.py

@@ -5,6 +5,7 @@ from supervisely.app.fastapi.subapp import (
     Application,
     get_name_from_env,
     _MainServer,
+    session_user_api,
 )
 from supervisely.app.fastapi.templating import Jinja2Templates
 from supervisely.app.fastapi.websocket import WebsocketManager

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,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/io/env.py

@@ -1,10 +1,14 @@
 # coding: utf-8
 import json
 import os
+from contextvars import ContextVar, Token
 from typing import Callable, List, Literal, Optional, Union
 
 RAISE_IF_NOT_FOUND = True
-
+_MULTIUSER_USER_CTX: ContextVar[Optional[Union[int, str]]] = ContextVar(
+    "supervisely_multiuser_app_user_id",
+    default=None,
+)
 
 def flag_from_env(s: str) -> bool:
     """Returns True if passed string is a flag, False otherwise.
@@ -771,3 +775,74 @@ def add_uploaded_ids_to_env(dataset_id: int, ids: List[int]) -> None:
     else:
         uploaded[str(dataset_id)].extend(ids)
     os.environ["UPLOADED_IDS"] = json.dumps(uploaded)
+
+
+def is_multiuser_mode_enabled() -> bool:
+    """Returns multiuser app mode flag from environment variable using following keys:
+        - SUPERVISELY_MULTIUSER_APP_MODE
+    :return: multiuser app mode flag
+    :rtype: bool
+    """
+    return _parse_from_env(
+        name="is_multiuser_mode_enabled",
+        keys=["SUPERVISELY_MULTIUSER_APP_MODE"],
+        default=False,
+        raise_not_found=False,
+        postprocess_fn=flag_from_env,
+    )
+
+
+def enable_multiuser_app_mode() -> None:
+    """
+    Enables multiuser app mode by setting the environment variable.
+    This function can be used to activate multiuser mode in the application allowing
+    separation of user DataJson/StateJson.
+    """
+    os.environ["SUPERVISELY_MULTIUSER_APP_MODE"] = "true"
+
+
+def disable_multiuser_app_mode() -> None:
+    """Disables multiuser app mode by removing the environment variable."""
+    os.environ.pop("SUPERVISELY_MULTIUSER_APP_MODE", None)
+
+
+def set_user_for_multiuser_app(user_id: Optional[Union[int, str]]) -> Token:
+    """
+    Sets the user ID for multiuser app mode by setting the environment variable.
+    This function should be used in multiuser mode to separate user DataJson/StateJson.
+
+    :param user_id: The user ID (or session key) to set for the current request.
+    :type user_id: int | str
+    :return: A context token that can be used to reset the user ID later.
+    :rtype: Token
+    :raises RuntimeError: If multiuser app mode is not enabled.
+    """
+    if not is_multiuser_mode_enabled():
+        raise RuntimeError("Multiuser app mode is not enabled. Cannot set user ID.")
+    return _MULTIUSER_USER_CTX.set(user_id)
+
+
+def reset_user_for_multiuser_app(token: Token) -> None:
+    """
+    Resets the user ID for multiuser app mode using the provided context token.
+
+    :param token: Context token obtained from `set_user_for_multiuser_app`.
+    :type token: Token
+    """
+    if not is_multiuser_mode_enabled():
+        return
+    _MULTIUSER_USER_CTX.reset(token)
+
+
+def user_from_multiuser_app() -> Optional[Union[int, str]]:
+    """
+    Retrieves the user ID for multiuser app mode from the environment variable.
+
+    :return: The user ID if set, otherwise None.
+    :rtype: Optional[Union[int, str]]
+    """
+    if not is_multiuser_mode_enabled():
+        return None
+    user_id = _MULTIUSER_USER_CTX.get(None)
+    if user_id is not None:
+        return user_id

{supervisely-6.73.452.dist-info → supervisely-6.73.454.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.452
+Version: 6.73.454
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.452.dist-info → supervisely-6.73.454.dist-info}/RECORD

@@ -82,28 +82,29 @@ supervisely/api/volume/volume_api.py,sha256=7mMfKY4HdzrbBvGZFE1SJiRi4OsgDyk3azz4
 supervisely/api/volume/volume_figure_api.py,sha256=Fs7j3h76kw7EI-o3vJHjpvL4Vxn3Fu-DzhArgK_qrPk,26523
 supervisely/api/volume/volume_object_api.py,sha256=F7pLV2MTlBlyN6fEKdxBSUatIMGWSuu8bWj3Hvcageo,2139
 supervisely/api/volume/volume_tag_api.py,sha256=yNGgXz44QBSW2VGlNDOVLqLXnH8Q2fFrxDFb_girYXA,3639
-supervisely/app/__init__.py,sha256=4yW79U_xvo7vjg6-vRhjtt0bO8MxMSx2PD8dMamS9Q8,633
-supervisely/app/content.py,sha256=MwUr2zlCMKU7YD_DIubq0WA2LuQ5dvlv1rsMp76paEg,8083
+supervisely/app/__init__.py,sha256=Z3RrMZBsaDuvSOqinD5K2rgQsQ-PuydQ1LaXbB4bXc8,651
+supervisely/app/content.py,sha256=x4EZ3BbqU_nAaoXqbRspebOXDv_b-Smt0TLC6Tk0Yq0,8484
 supervisely/app/exceptions.py,sha256=w01IUAq7SUu4FJDahTdR9tCoDnbobFQ6huL0uHCWxZs,1370
 supervisely/app/export_template.py,sha256=_fI8B2Up0luRbRC6NxaJt-c5Z9MeJYh-RzFv0GARKSw,2801
 supervisely/app/import_template.py,sha256=H2jaVekt9GZvz6FdzfrT8sJTS3VJY8JeXTCJiRv8jWI,50040
 supervisely/app/jinja2.py,sha256=H3TCoLDCdTfO7Fq3ZDtcBNqfyZBlNr7p8qcKrE88HE8,341
-supervisely/app/singleton.py,sha256=g8FI4vqt76tXF09tsb05N_N4ouTI0LJGZekrgVkulg0,406
+supervisely/app/singleton.py,sha256=-ylcXdKL-qsqgnuPl4vjr62vqxKrjLq_xeFHMqWYI64,1334
 supervisely/app/widgets_context.py,sha256=JkAd4o87eqhkGJbai-Yq6YHULiPsbp1VwGOSBRxTOgY,313
 supervisely/app/development/__init__.py,sha256=f2SpWBcCFPbSEBsJijH25eCAK8NcY2An5NU9vPgCBVo,135
 supervisely/app/development/development.py,sha256=Ij3tn7HmkHr2RRoYxlpK9xkTGnpFjZwy2kArn6ZxVnA,12505
 supervisely/app/development/sly-net.sh,sha256=M-RWQ7kygrJm88WGsOW0tEccO0fDgj_xGLI8Ifm-Ie4,1111
-supervisely/app/fastapi/__init__.py,sha256=kNhkaGuBKn9-GNnPOmikIHqhjL-j66xmZaBbjCmXfAo,460
+supervisely/app/fastapi/__init__.py,sha256=ZT7hgv34YNg0CBWHcdvksqXHCcN23f1YdXp-JZd87Ek,482
 supervisely/app/fastapi/custom_static_files.py,sha256=5todaVIvUG9sAt6vu1IujJn8N7zTmFhVUfeCVbuXbvc,3391
 supervisely/app/fastapi/dialog_window.html,sha256=ffaAxjK0TQRa7RrY5oA4uE6RzFuS0VnRG1pfoIzTqVM,1183
 supervisely/app/fastapi/index.html,sha256=dz_e-0RE5ZbOU0ToUaEHe1ROI6Tc3SPL-mHt1CpZTxQ,8793
+supervisely/app/fastapi/multi_user.py,sha256=m8Iy0ibTy85C7JkkovcRbDOirmIaz8BOOmAckDLGItk,3341
 supervisely/app/fastapi/no_html_main.html,sha256=NhQP7noyORBx72lFh1CQKgBRupkWjiq6Gaw-9Hkvg7c,37
 supervisely/app/fastapi/offline.py,sha256=CwMMkJ1frD6wiZS-SEoNDtQ1UJcJe1Ob6ohE3r4CQL8,7414
 supervisely/app/fastapi/request.py,sha256=NU7rKmxJ1pfkDZ7_yHckRcRAueJRQIqCor11UO2OHr8,766
-supervisely/app/fastapi/subapp.py,sha256=GxMeYMy7lCkef8R_61F2XqxKjJjtyAk7CNDSCIc07ZY,50127
+supervisely/app/fastapi/subapp.py,sha256=N5ly1SmAslUlzA2b8NRscaTTYkoubak3xmYkp5er8t4,51854
 supervisely/app/fastapi/templating.py,sha256=etFkNJKvoWsHrHpmgDUuybZXcLuzS1IBRxvPnZlT9K8,2928
 supervisely/app/fastapi/utils.py,sha256=t_UquzlFrdkKtAJmH6eJ279pE8Aa3BaIu4XjX-SEaIE,946
-supervisely/app/fastapi/websocket.py,sha256=TlRSPOAhRItTv1HGvdukK1ZvhRjMUxRa-lJlsRR9rJw,1308
+supervisely/app/fastapi/websocket.py,sha256=2RqHoN7a_qPz8WMDSxCih69yyi11AaMiVtBhsyg4gxg,3953
 supervisely/app/v1/__init__.py,sha256=OdU0PYv6hLwahYoyaLFO8m3cbJSchvPbqxuG1N3T734,848
 supervisely/app/v1/app_config.md,sha256=-8GKbiQoX25RhEj3EDJ7TxiYuFw5wL2TO3qV5AJLZTs,2536
 supervisely/app/v1/app_service.py,sha256=KGWns_M3OkQLdtsGpH3rBlA2hmSeqGkA-M5q5sTqxe4,23090
@@ -735,7 +736,7 @@ supervisely/imaging/font.py,sha256=0XcmWhlw7y2PAhrWgcsfInyRWj0WnlFpMSEXXilR8UA,2
 supervisely/imaging/image.py,sha256=1KNc4qRbP9OlI4Yta07Kc2ohAgSBJ_9alF9Jag74w30,41873
 supervisely/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/io/docker_utils.py,sha256=hb_HXGM8IYB0PF-nD7NxMwaHgzaxIFxofsUzQ_RCUZI,7935
-supervisely/io/env.py,sha256=wf15PXGd_xzY6c4g8ywPGcZ25A8a9Jv_BXg9-x61cgg,24884
+supervisely/io/env.py,sha256=9H9qXeqxw59zMAhSqlxucSc0MRfK6XI50SFcKhGMq4I,27448
 supervisely/io/exception_handlers.py,sha256=22LPlLgyq59DnrhpaFrbGBYJE7uxO64VTZjsPJC0PLE,36757
 supervisely/io/fs.py,sha256=pzNAK5fbT3G-7PKRY5oYcOPjgXeZ9x5Dyry7fzzZsr8,63604
 supervisely/io/fs_cache.py,sha256=985gvBGzveLcDudgz10E4EWVjP9jxdU1Pa0GFfCBoCA,6520
@@ -1128,9 +1129,9 @@ supervisely/worker_proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 supervisely/worker_proto/worker_api_pb2.py,sha256=VQfi5JRBHs2pFCK1snec3JECgGnua3Xjqw_-b3aFxuM,59142
 supervisely/worker_proto/worker_api_pb2_grpc.py,sha256=3BwQXOaP9qpdi0Dt9EKG--Lm8KGN0C5AgmUfRv77_Jk,28940
 supervisely_lib/__init__.py,sha256=yRwzEQmVwSd6lUQoAUdBngKEOlnoQ6hA9ZcoZGJRNC4,331
-supervisely-6.73.452.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.452.dist-info/METADATA,sha256=o1IIrOeH7ZDHD8bH7l_R6v7BpmNSoI1i5P0O0c-eNFg,35480
-supervisely-6.73.452.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-supervisely-6.73.452.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.452.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.452.dist-info/RECORD,,
+supervisely-6.73.454.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.454.dist-info/METADATA,sha256=7C7wpc584Nvw35hqqz7ByMADZ42r06AvxDFgg9yO4Hk,35480
+supervisely-6.73.454.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+supervisely-6.73.454.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.454.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.454.dist-info/RECORD,,