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

supervisely/api/project_api.py

@@ -12,10 +12,12 @@ from typing import (
     Any,
     Callable,
     Dict,
+    Generator,
     List,
     Literal,
     NamedTuple,
     Optional,
+    Tuple,
     Union,
 )
 
@@ -38,12 +40,14 @@ from supervisely.annotation.annotation import TagCollection
 from supervisely.annotation.obj_class import ObjClass
 from supervisely.annotation.obj_class_collection import ObjClassCollection
 from supervisely.annotation.tag_meta import TagMeta, TagValueType
+from supervisely.api.dataset_api import DatasetInfo
 from supervisely.api.module_api import (
     ApiField,
     CloneableModuleApi,
     RemoveableModuleApi,
     UpdateableModule,
 )
+from supervisely.io.env import upload_count, uploaded_ids
 from supervisely.io.json import dump_json_file, load_json_file
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.project.project_meta import ProjectMetaJsonFields as MetaJsonF
@@ -264,9 +268,10 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
 
     def get_list(
         self,
-        workspace_id: int,
+        workspace_id: Optional[int] = None,
         filters: Optional[List[Dict[str, str]]] = None,
         fields: List[str] = [],
+        team_id: Optional[int] = None,
     ) -> List[ProjectInfo]:
         """
         List of Projects in the given Workspace.
@@ -275,12 +280,13 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         If you need version information, use :func:`get_info_by_id`.
 
         :param workspace_id: Workspace ID in which the Projects are located.
-        :type workspace_id: int
+        :type workspace_id: int, optional
         :param filters: List of params to sort output Projects.
         :type filters: List[dict], optional
         :param fields: The list of api fields which will be returned with the response. You must specify all fields you want to receive, not just additional ones.
         :type fields: List[str]
-
+        :param team_id: Team ID in which the Projects are located.
+        :type team_id: int, optional
         :return: List of all projects with information for the given Workspace. See :class:`info_sequence<info_sequence>`
         :rtype: :class: `List[ProjectInfo]`
         :Usage example:
@@ -357,6 +363,11 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             # ]
 
         """
+        if team_id is not None and workspace_id is not None:
+            raise ValueError(
+                "team_id and workspace_id cannot be used together. Please provide only one of them."
+            )
+
         method = "projects.list"
 
         debug_message = "While getting list of projects, the following fields are not available: "
@@ -367,11 +378,33 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
                 self.debug_messages_sent["get_list_versions"] = True
                 logger.debug(debug_message + "version. ")
 
+        default_fields = [
+            ApiField.ID,
+            ApiField.WORKSPACE_ID,
+            ApiField.TITLE,
+            ApiField.DESCRIPTION,
+            ApiField.SIZE,
+            ApiField.README,
+            ApiField.TYPE,
+            ApiField.CREATED_AT,
+            ApiField.UPDATED_AT,
+            ApiField.CUSTOM_DATA,
+            ApiField.GROUP_ID,
+            ApiField.CREATED_BY_ID[0][0],
+        ]
+
+        if fields:
+            merged_fields = list(set(default_fields + fields))
+            fields = list(dict.fromkeys(merged_fields))
+
         data = {
-            ApiField.WORKSPACE_ID: workspace_id,
             ApiField.FILTER: filters or [],
             ApiField.FIELDS: fields,
         }
+        if workspace_id is not None:
+            data[ApiField.WORKSPACE_ID] = workspace_id
+        if team_id is not None:
+            data[ApiField.GROUP_ID] = team_id
 
         return self.get_list_all_pages(method, data)
 
@@ -2129,7 +2162,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             #                       reference_image_url = None,
             #                       custom_data = None,
             #                       backup_archive = None,
-            #                       teamd_id = 1,
+            #                       team_id = 1,
             #                       import_settings = {},
             #                   ),
             #                   ProjectInfo(id = 23,
@@ -2147,7 +2180,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             #                       reference_image_url = None,
             #                       custom_data = None,
             #                       backup_archive = None),
-            #                       teamd_id = 1,
+            #                       team_id = 1,
             #                       import_settings = {},
             #                   )
             #                 ]
@@ -2455,6 +2488,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         request_body = {
             ApiField.PROJECT_ID: project_id,
             ApiField.LIMIT: limit,
+            ApiField.UNIQUE_ITEMS: limit,  # the same as limit, but for diverse search
         }
 
         if dataset_id is not None:
@@ -2526,3 +2560,176 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             api.project.calculate_embeddings(project_id)
         """
         self._api.post("embeddings.calculate-project-embeddings", {ApiField.PROJECT_ID: id})
+
+    def recreate_structure_generator(
+        self,
+        src_project_id: int,
+        dst_project_id: Optional[int] = None,
+        dst_project_name: Optional[str] = None,
+    ) -> Generator[Tuple[DatasetInfo, DatasetInfo], None, None]:
+        """This method can be used to recreate a project with hierarchial datasets (without the data itself) and
+        yields the tuple of source and destination DatasetInfo objects.
+
+        :param src_project_id: Source project ID
+        :type src_project_id: int
+        :param dst_project_id: Destination project ID
+        :type dst_project_id: int, optional
+        :param dst_project_name: Name of the destination project. If `dst_project_id` is None, a new project will be created with this name. If `dst_project_id` is provided, this parameter will be ignored.
+        :type dst_project_name: str, optional
+
+        :return: Generator of tuples of source and destination DatasetInfo objects
+        :rtype: Generator[Tuple[DatasetInfo, DatasetInfo], None, None]
+
+        :Usage example:
+
+        .. code-block:: python
+
+            import supervisely as sly
+
+            api = sly.Api.from_env()
+
+            src_project_id = 123
+            dst_project_id = api.project.create("new_project", "images").id
+
+            for src_ds, dst_ds in api.project.recreate_structure_generator(src_project_id, dst_project_id):
+                print(f"Recreated dataset {src_ds.id} -> {dst_ds.id}")
+                # Implement your logic here to process the datasets.
+        """
+        if dst_project_id is None:
+            src_project_info = self._api.project.get_info_by_id(src_project_id)
+            dst_project_info = self._api.project.create(
+                src_project_info.workspace_id,
+                dst_project_name or f"Recreation of {src_project_info.name}",
+                src_project_info.type,
+                src_project_info.description,
+                change_name_if_conflict=True,
+            )
+            dst_project_id = dst_project_info.id
+
+        datasets = self._api.dataset.get_list(src_project_id, recursive=True, include_custom_data=True)
+        src_to_dst_ids = {}
+
+        for src_dataset_info in datasets:
+            dst_dataset_info = self._api.dataset.create(
+                dst_project_id,
+                src_dataset_info.name,
+                description=src_dataset_info.description,
+                parent_id=src_to_dst_ids.get(src_dataset_info.parent_id),
+                custom_data=src_dataset_info.custom_data,
+            )
+            src_to_dst_ids[src_dataset_info.id] = dst_dataset_info.id
+
+            yield src_dataset_info, dst_dataset_info
+
+    def recreate_structure(
+        self,
+        src_project_id: int,
+        dst_project_id: Optional[int] = None,
+        dst_project_name: Optional[str] = None,
+    ) -> Tuple[List[DatasetInfo], List[DatasetInfo]]:
+        """This method can be used to recreate a project with hierarchial datasets (without the data itself).
+
+        :param src_project_id: Source project ID
+        :type src_project_id: int
+        :param dst_project_id: Destination project ID
+        :type dst_project_id: int, optional
+        :param dst_project_name: Name of the destination project. If `dst_project_id` is None, a new project will be created with this name. If `dst_project_id` is provided, this parameter will be ignored.
+        :type dst_project_name: str, optional
+
+        :return: Destination project ID
+        :rtype: int
+
+        :Usage example:
+
+        .. code-block:: python
+
+            import supervisely as sly
+
+            api = sly.Api.from_env()
+
+            src_project_id = 123
+            dst_project_name = "New Project"
+
+            dst_project_id = api.project.recreate_structure(src_project_id, dst_project_name=dst_project_name)
+            print(f"Recreated project {src_project_id} -> {dst_project_id}")
+        """
+        infos = []
+        for src_info, dst_info in self.recreate_structure_generator(
+            src_project_id, dst_project_id, dst_project_name
+        ):
+            infos.append((src_info, dst_info))
+
+        return infos
+
+    def add_import_history(self, id: int, task_id: int) -> None:
+        """
+        Adds import history to project info. Gets task info and adds it to project custom data.
+
+        :param id: Project ID
+        :type id: int
+        :param task_id: Task ID
+        :type task_id: int
+        :return: None
+        :rtype: :class:`NoneType`
+        :Usage example:
+         .. code-block:: python
+            import os
+            from dotenv import load_dotenv
+
+            import supervisely as sly
+
+            # Load secrets and create API object from .env file (recommended)
+            # Learn more here: https://developer.supervisely.com/getting-started/basics-of-authentication
+            load_dotenv(os.path.expanduser("~/supervisely.env"))
+            api = sly.Api.from_env()
+
+            project_id = 123
+            task_id = 456
+            api.project.add_import_history(project_id, task_id)
+        """
+
+        task_info = self._api.task.get_info_by_id(task_id)
+        module_id = task_info.get("meta", {}).get("app", {}).get("moduleId")
+        slug = None
+        if module_id is not None:
+            module_info = self._api.app.get_ecosystem_module_info(module_id)
+            slug = module_info.slug
+
+        items_count = upload_count()
+        items_count = {int(k): v for k, v in items_count.items()}
+        uploaded_images = uploaded_ids()
+        uploaded_images = {int(k): v for k, v in uploaded_images.items()}
+        total_items = sum(items_count.values()) if len(items_count) > 0 else 0
+        app = task_info.get("meta", {}).get("app")
+        app_name = app.get("name") if app else None
+        app_version = app.get("version") if app else None
+        data = {
+            "task_id": task_id,
+            "app": {"name": app_name, "version": app_version},
+            "slug": slug,
+            "status": task_info.get(ApiField.STATUS),
+            "user_id": task_info.get(ApiField.USER_ID),
+            "team_id": task_info.get(ApiField.TEAM_ID),
+            "timestamp": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
+            "source_state": task_info.get("settings", {}).get("message", {}).get("state"),
+            "items_count": total_items,
+            "datasets": [
+                {
+                    "id": ds,
+                    "items_count": items_count[ds],
+                    "uploaded_images": uploaded_images.get(ds, []),
+                }
+                for ds in items_count.keys()
+            ],
+        }
+
+        project_info = self.get_info_by_id(id)
+
+        custom_data = project_info.custom_data or {}
+        if "import_history" not in custom_data:
+            custom_data["import_history"] = {"tasks": []}
+        if "tasks" not in custom_data["import_history"]:
+            custom_data["import_history"]["tasks"] = []
+        custom_data["import_history"]["tasks"].append(data)
+
+        self.edit_info(id, custom_data=custom_data)

supervisely/api/task_api.py

@@ -24,6 +24,7 @@ from supervisely.api.module_api import (
     WaitingTimeExceeded,
 )
 from supervisely.collection.str_enum import StrEnum
+from supervisely.io.env import app_categories
 from supervisely.io.fs import (
     ensure_base_path,
     get_file_hash,
@@ -652,6 +653,8 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         project_preview: Optional[str] = None,
     ) -> Dict:
         """set_output_project"""
+        if "import" in app_categories():
+            self._api.project.add_import_history(project_id, task_id)
         if project_name is None:
             project = self._api.project.get_info_by_id(project_id, raise_error=True)
             project_name = project.name
@@ -1007,11 +1010,12 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         Example of experiment_info:
 
             experiment_info = {
-                'experiment_name': '247_Lemons_RT-DETRv2-M',
+                'experiment_name': '247 Lemons RT-DETRv2-M',
                 'framework_name': 'RT-DETRv2',
                 'model_name': 'RT-DETRv2-M',
                 'task_type': 'object detection',
                 'project_id': 76,
+                'project_version': {'id': 222, 'version': 4},
                 'task_id': 247,
                 'model_files': {'config': 'model_config.yml'},
                 'checkpoints': ['checkpoints/best.pth', 'checkpoints/checkpoint0025.pth', 'checkpoints/checkpoint0050.pth', 'checkpoints/last.pth'],
@@ -1022,10 +1026,13 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
                 'train_val_split': 'train_val_split.json',
                 'train_size': 4,
                 'val_size': 2,
+                'train_collection_id': 530,
+                'val_collection_id': 531,
                 'hyperparameters': 'hyperparameters.yaml',
                 'hyperparameters_id': 45234,
                 'artifacts_dir': '/experiments/76_Lemons/247_RT-DETRv2/',
                 'datetime': '2025-01-22 18:13:43',
+                'experiment_report_id': 87654,
                 'evaluation_report_id': 12961,
                 'evaluation_report_link': 'https://app.supervisely.com/model-benchmark?id=12961',
                 'evaluation_metrics': {
@@ -1046,6 +1053,9 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
                     'type': 'tensorboard',
                     'link': '/experiments/76_Lemons/247_RT-DETRv2/logs/'
                 },
+                # These fields are present only in task_info
+                'project_preview': 'https://app.supervisely.com/...',
+                'has_report': True,
             }
         """
         output = {

supervisely/api/video/video_annotation_api.py

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

supervisely/api/video/video_api.py

@@ -5,6 +5,7 @@ import asyncio
 import datetime
 import json
 import os
+import re
 import urllib.parse
 from functools import partial
 from typing import (
@@ -23,7 +24,11 @@ from typing import (
 import aiofiles
 from numerize.numerize import numerize
 from requests import Response
-from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
+from requests_toolbelt import (
+    MultipartDecoder,
+    MultipartEncoder,
+    MultipartEncoderMonitor,
+)
 from tqdm import tqdm
 
 import supervisely.io.fs as sly_fs
@@ -1186,6 +1191,41 @@ class VideoApi(RemoveableBulkModuleApi):
                 if progress_cb is not None:
                     progress_cb(len(chunk))
 
+    def download_frames(
+        self, video_id: int, frames: List[int], paths: List[str], progress_cb=None
+    ) -> None:
+        endpoint = "videos.bulk.download-frame"
+        response: Response = self._api.get(
+            endpoint,
+            params={},
+            data={ApiField.VIDEO_ID: video_id, ApiField.FRAMES: frames},
+            stream=True,
+        )
+        response.raise_for_status()
+
+        files = {frame_n: None for frame_n in frames}
+        file_paths = {frame_n: path for frame_n, path in zip(frames, paths)}
+
+        try:
+            decoder = MultipartDecoder.from_response(response)
+            for part in decoder.parts:
+                content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
+                # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
+                # The regex has 2 capture group: one for the prefix and one for the actual name value.
+                frame_n = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
+                if files[frame_n] is None:
+                    file_path = file_paths[frame_n]
+                    files[frame_n] = open(file_path, "wb")
+                    if progress_cb is not None:
+                        progress_cb(1)
+                f = files[frame_n]
+                f.write(part.content)
+
+        finally:
+            for f in files.values():
+                if f is not None:
+                    f.close()
+
     def download_range_by_id(
         self,
         id: int,
@@ -2610,3 +2650,41 @@ class VideoApi(RemoveableBulkModuleApi):
 
             tasks.append(task)
         await asyncio.gather(*tasks)
+
+    def rename(
+        self,
+        id: int,
+        name: str,
+    ) -> VideoInfo:
+        """Renames Video with given ID to a new name.
+
+        :param id: Video ID in Supervisely.
+        :type id: int
+        :param name: New Video name.
+        :type name: str
+        :return: Information about updated Video.
+        :rtype: :class:`VideoInfo`
+
+        :Usage example:
+
+        .. code-block:: python
+
+            import supervisely as sly
+
+            api = sly.Api.from_env()
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+
+            video_id = 123456
+            new_video_name = "VID_3333_new.mp4"
+
+            api.video.rename(id=video_id, name=new_video_name)
+        """
+
+        data = {
+            ApiField.ID: id,
+            ApiField.NAME: name,
+        }
+
+        response = self._api.post("images.editInfo", data)
+        return self._convert_json_info(response.json())

supervisely/api/video/video_figure_api.py

@@ -10,7 +10,7 @@ from supervisely.api.module_api import ApiField
 from supervisely.geometry.geometry import Geometry
 from supervisely.video_annotation.key_id_map import KeyIdMap
 from supervisely.video_annotation.video_figure import VideoFigure
-
+from supervisely.annotation.label import LabelingStatus
 
 class VideoFigureApi(FigureApi):
     """
@@ -26,6 +26,7 @@ class VideoFigureApi(FigureApi):
         geometry_type: str,
         track_id: Optional[int] = None,
         meta: Optional[dict] = None,
+        status: Optional[LabelingStatus] = None,
     ) -> int:
         """
         Create new VideoFigure for given frame in given video ID.
@@ -42,6 +43,10 @@ class VideoFigureApi(FigureApi):
         :type geometry_type: str
         :param track_id: int, optional.
         :type track_id: int, optional
+        :param meta: Meta data for VideoFigure.
+        :type meta: dict, optional
+        :param status: Labeling status. Specifies if the VideoFigure was created by NN model, manually or created by NN and then manually corrected.
+        :type status: LabelingStatus, optional
         :return: New figure ID
         :rtype: :class:`int`
         :Usage example:
@@ -64,13 +69,16 @@ class VideoFigureApi(FigureApi):
         """
         if meta is None:
             meta = {}
+        meta = {**(meta or {}), ApiField.FRAME: frame_index}
+
         return super().create(
             video_id,
             object_id,
-            {**meta, ApiField.FRAME: frame_index},
+            meta,
             geometry_json,
             geometry_type,
             track_id,
+            status=status,
         )
 
     def append_bulk(self, video_id: int, figures: List[VideoFigure], key_id_map: KeyIdMap) -> None:
@@ -115,13 +123,15 @@ class VideoFigureApi(FigureApi):
 
         self._append_bulk(video_id, figures_json, keys, key_id_map)
 
-    def update(self, figure_id: int, geometry: Geometry) -> None:
+    def update(self, figure_id: int, geometry: Geometry, status: Optional[LabelingStatus] = None) -> None:
         """Updates figure feometry with given ID in Supervisely with new Geometry object.
 
         :param figure_id: ID of the figure to update
         :type figure_id: int
         :param geometry: Supervisely Gepmetry object
         :type geometry: Geometry
+        :param status: Labeling status. Specifies if the VideoFigure was created by NN model, manually or created by NN and then manually corrected.
+        :type status: LabelingStatus, optional
         :Usage example:
 
          .. code-block:: python
@@ -141,13 +151,17 @@ class VideoFigureApi(FigureApi):
 
             api.video.figure.update(figure_id, new_geometry)
         """
-        self._api.post(
-            "figures.editInfo",
-            {
-                ApiField.ID: figure_id,
-                ApiField.GEOMETRY: geometry.to_json(),
-            },
-        )
+        payload = {
+            ApiField.ID: figure_id,
+            ApiField.GEOMETRY: geometry.to_json(),
+        }
+
+        if status is not None:
+            nn_created,nn_updated = LabelingStatus.to_flags(status)
+            payload[ApiField.NN_CREATED] = nn_created
+            payload[ApiField.NN_UPDATED] = nn_updated
+
+        self._api.post("figures.editInfo", payload)
 
     def download(
         self, dataset_id: int, video_ids: List[int] = None, skip_geometry: bool = False, **kwargs
@@ -161,7 +175,6 @@ class VideoFigureApi(FigureApi):
         :type video_ids: List[int], optional
         :param skip_geometry: Skip the download of figure geometry. May be useful for a significant api request speed increase in the large datasets.
         :type skip_geometry: bool
-
         :return: A dictionary where keys are video IDs and values are lists of figures.
         :rtype: :class: `Dict[int, List[FigureInfo]]`
         """

supervisely/api/volume/volume_api.py

@@ -1455,3 +1455,41 @@ class VolumeApi(RemoveableBulkModuleApi):
             )
             tasks.append(task)
         await asyncio.gather(*tasks)
+
+    def rename(
+        self,
+        id: int,
+        name: str,
+    ) -> VolumeInfo:
+        """Renames Volume with given ID to a new name.
+
+        :param id: Volume ID in Supervisely.
+        :type id: int
+        :param name: New Volume name.
+        :type name: str
+        :return: Information about updated Volume.
+        :rtype: :class:`VolumeInfo`
+
+        :Usage example:
+
+        .. code-block:: python
+
+            import supervisely as sly
+
+            api = sly.Api.from_env()
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+
+            volume_id = 123456
+            new_volume_name = "3333_new.nrrd"
+
+            api.volume.rename(id=volume_id, name=new_volume_name)
+        """
+
+        data = {
+            ApiField.ID: id,
+            ApiField.NAME: name,
+        }
+
+        response = self._api.post("images.editInfo", data)
+        return self._convert_json_info(response.json())

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