supervisely 6.73.452__tar.gz → 6.73.453__tar.gz

{supervisely-6.73.452/supervisely.egg-info → supervisely-6.73.453}/PKG-INFO

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

{supervisely-6.73.452 → supervisely-6.73.453}/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-6.73.453/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-6.73.452 → supervisely-6.73.453}/supervisely/app/fastapi/subapp.py

@@ -1,17 +1,18 @@
+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
@@ -32,6 +33,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 +70,7 @@ HEALTH_ENDPOINTS = ["/health", "/is_ready"]
 # Context variable for response time
 response_time_ctx: ContextVar[float] = ContextVar("response_time", default=None)
 
+
 class ReadyzFilter(logging.Filter):
     def filter(self, record):
         if "/readyz" in record.getMessage() or "/livez" in record.getMessage():
@@ -623,18 +626,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 +828,55 @@ 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
+                    )
+                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)

supervisely-6.73.453/supervisely/app/fastapi/websocket.py

@@ -0,0 +1,107 @@
+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
+
+
+class WebsocketManager(metaclass=Singleton):
+    def __init__(self, path="/sly-app-ws"):
+        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:
+            return
+        self.app = app
+        self.app.add_api_websocket_route(path=self.path, endpoint=self.endpoint)
+
+    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):
+        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):
+        await self.connect(websocket)
+        try:
+            while True:
+                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-6.73.453/supervisely/app/singleton.py

@@ -0,0 +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-6.73.452 → supervisely-6.73.453}/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 → supervisely-6.73.453/supervisely.egg-info}/PKG-INFO

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

{supervisely-6.73.452 → supervisely-6.73.453}/supervisely.egg-info/SOURCES.txt

@@ -107,6 +107,7 @@ supervisely/app/fastapi/__init__.py
 supervisely/app/fastapi/custom_static_files.py
 supervisely/app/fastapi/dialog_window.html
 supervisely/app/fastapi/index.html
+supervisely/app/fastapi/multi_user.py
 supervisely/app/fastapi/no_html_main.html
 supervisely/app/fastapi/offline.py
 supervisely/app/fastapi/request.py

supervisely-6.73.452/supervisely/app/fastapi/websocket.py

@@ -1,39 +0,0 @@
-from typing import List
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-from supervisely.app.singleton import Singleton
-
-
-class WebsocketManager(metaclass=Singleton):
-    def __init__(self, path="/sly-app-ws"):
-        self.app = None
-        self.path = path
-        self.active_connections: List[WebSocket] = []
-
-    def set_app(self, app: FastAPI):
-        if self.app is not None:
-            return
-        self.app = app
-        self.app.add_api_websocket_route(path=self.path, endpoint=self.endpoint)
-
-    async def connect(self, websocket: WebSocket):
-        await websocket.accept()
-        self.active_connections.append(websocket)
-
-    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:
-            await connection.send_json(d)
-
-    async def endpoint(self, websocket: WebSocket):
-        await self.connect(websocket)
-        try:
-            while True:
-                data = await websocket.receive_text()
-        except WebSocketDisconnect:
-            self.disconnect(websocket)

supervisely-6.73.452/supervisely/app/singleton.py

@@ -1,11 +0,0 @@
-class Singleton(type):
-    _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)
-            return cls._instances[cls]
-        else:
-            return super(Singleton, cls).__call__(*args, **kwargs)