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

supervisely/api/storage_api.py

@@ -228,7 +228,9 @@ class StorageApi(FileApi):
         path_infos = self.list(team_id, parent_dir, recursive=False, return_type="dict")
         for info in path_infos:
             if info["type"] == path_type:
-                if info["path"].rstrip("/") == remote_path.rstrip("/"):
+                if path_type == "file" and info["path"] == remote_path:
+                    return True
+                elif path_type == "folder" and info["path"].rstrip("/") == remote_path.rstrip("/"):
                     return True
         return False
 

supervisely/api/task_api.py

@@ -390,6 +390,7 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         redirect_requests: Optional[Dict[str, int]] = {},
         limit_by_workspace: bool = False,
         kubernetes_settings: Optional[Union[KubernetesSettings, Dict[str, Any]]] = None,
+        multi_user_session: bool = False,
     ) -> Dict[str, Any]:
         """Starts the application task on the agent.
 
@@ -428,6 +429,11 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         :type limit_by_workspace: bool, optional
         :param kubernetes_settings: Kubernetes settings for the application.
         :type kubernetes_settings: Union[KubernetesSettings, Dict[str, Any]], optional
+        :param multi_user_session: If True, the application session will be created as multi-user.
+                                   In this case, multiple users will be able to connect to the same application session.
+                                   All users will have separate application states.
+                                   Available only for applications that support multi-user sessions.
+        :type multi_user_session: bool, default is False
         :return: Task information in JSON format.
         :rtype: Dict[str, Any]
 
@@ -497,6 +503,11 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
             data[ApiField.APP_ID] = app_id
         if module_id is not None:
             data[ApiField.MODULE_ID] = module_id
+        if multi_user_session:
+            # * Enables single multi-user session mode for all users in the users_ids list.
+            # * Otherwise, if users_ids contains multiple IDs, separate single-user sessions will be created for each.
+            # * If users_ids is empty, a session is created only for the current user.
+            data[ApiField.SINGLE_SESSION_MODE] = multi_user_session
         resp = self._api.post(method="tasks.run.app", data=data)
         task = resp.json()[0]
         if "id" not in task:
@@ -805,8 +816,8 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
     ):
         """
         Update given task metadata
-        :param id: int — task id
-        :param data: dict — meta data to update
+        :param id: int - task id
+        :param data: dict - meta data to update
         """
         if type(data) == dict:
             data.update({"id": id})

supervisely/api/team_api.py

@@ -132,7 +132,7 @@ class ActivityAction:
 class UsageInfo(NamedTuple):
     """ """
 
-    plan: str
+    plan: Optional[str]
 
 
 class TeamInfo(NamedTuple):
@@ -144,7 +144,7 @@ class TeamInfo(NamedTuple):
     role: str
     created_at: str
     updated_at: str
-    usage: UsageInfo
+    usage: Optional[UsageInfo]
 
 
 class TeamApi(ModuleNoParent, UpdateableModule):
@@ -565,5 +565,6 @@ class TeamApi(ModuleNoParent, UpdateableModule):
         res = super()._convert_json_info(info, skip_missing=skip_missing)
         res_dict = res._asdict()
         if isinstance(res_dict.get("usage"), dict):
-            res_dict["usage"] = UsageInfo(**res_dict["usage"])
+            usage_dict = {f: res_dict["usage"].get(f) for f in UsageInfo._fields}
+            res_dict["usage"] = UsageInfo(**usage_dict)
         return TeamInfo(**res_dict)

supervisely/api/video/video_annotation_api.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import asyncio
+from collections import defaultdict
 from typing import Callable, Dict, List, Optional, Union
 
 from tqdm import tqdm
@@ -13,6 +14,7 @@ from supervisely.io.json import load_json_file
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.video_annotation.key_id_map import KeyIdMap
 from supervisely.video_annotation.video_annotation import VideoAnnotation
+from supervisely.video_annotation.video_tag_collection import VideoTagCollection
 
 
 class VideoAnnotationAPI(EntityAnnotationAPI):
@@ -173,7 +175,6 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
             api.video.annotation.upload_paths(video_ids, ann_paths, meta)
         """
         # video_ids from the same dataset
-
         for video_id, ann_path in zip(video_ids, ann_paths):
             ann_json = load_json_file(ann_path)
             ann = VideoAnnotation.from_json(ann_json, project_meta)
@@ -183,6 +184,119 @@ class VideoAnnotationAPI(EntityAnnotationAPI):
             if progress_cb is not None:
                 progress_cb(1)
 
+    def upload_paths_multiview(
+        self,
+        video_ids: List[int],
+        ann_paths: List[str],
+        project_meta: ProjectMeta,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> None:
+        """
+        Upload VideoAnnotations for multi-view video project.
+        All provided video ids must belong to the same project and dataset.
+
+        Objects with the same key are created only once and shared between videos.
+        In this mode annotation objects are created without binding to a specific entityId.
+
+        :param video_ids: Video IDs in Supervisely.
+        :type video_ids: List[int]
+        :param ann_paths: Paths to annotations on local machine.
+        :type ann_paths: List[str]
+        :param project_meta: Input :class:`ProjectMeta<supervisely.project.project_meta.ProjectMeta>` for VideoAnnotations.
+        :type project_meta: ProjectMeta
+        :param progress_cb: Function for tracking upload progress.
+        :type progress_cb: tqdm or callable, optional
+        :return: None
+        :rtype: :class:`NoneType`
+        """
+        if len(video_ids) != len(ann_paths):
+            raise RuntimeError(
+                f'Can not match "video_ids" and "ann_paths" lists, len(video_ids) != len(ann_paths): {len(video_ids)} != {len(ann_paths)}'
+            )
+        if len(video_ids) == 0:
+            return
+
+        anns = []
+        for ann_path in ann_paths:
+            ann_json = load_json_file(ann_path)
+            ann = VideoAnnotation.from_json(ann_json, project_meta)
+            anns.append(ann)
+
+        self.upload_anns_multiview(video_ids, anns, progress_cb)
+
+    def upload_anns_multiview(
+        self,
+        video_ids: List[int],
+        anns: List[VideoAnnotation],
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
+    ) -> None:
+        """
+        Upload already constructed VideoAnnotation objects for multi-view video project.
+        All provided video ids must belong to the same project and dataset.
+
+        Objects with the same key are created only once and shared between videos.
+        In this mode annotation objects are created without binding to a specific entityId.
+
+        :param video_ids: Video IDs in Supervisely.
+        :type video_ids: List[int]
+        :param anns: List of VideoAnnotation objects corresponding to the video_ids.
+        :type anns: List[VideoAnnotation]
+        :param progress_cb: Function for tracking upload progress (by number of figures).
+        :type progress_cb: tqdm or callable, optional
+        :return: None
+        :rtype: :class:`NoneType`
+        """
+        if len(video_ids) != len(anns):
+            raise RuntimeError(
+                'Can not match "video_ids" and "anns" lists, len(video_ids) != len(anns)'
+            )
+        if len(video_ids) == 0:
+            return
+
+        try:
+            video_infos = self._api.video.get_info_by_id_batch(video_ids)
+        except RuntimeError as e:
+            raise RuntimeError("All videos must belong to the same project and dataset.") from e
+
+        project_id = video_infos[0].project_id
+        dataset_id = video_infos[0].dataset_id
+
+        tag_api = self._api.video.tag
+        object_api = self._api.video.object
+        figure_api = self._api.video.figure
+
+        key_id_map = KeyIdMap()
+        for video_id, ann in zip(video_ids, anns):
+            tag_api.append_to_entity(video_id, project_id, ann.tags, key_id_map=key_id_map)
+            new_objects = []
+            for obj in ann.objects:
+                if key_id_map.get_object_id(obj.key()) is None:
+                    new_objects.append(obj)
+            if len(new_objects) > 0:
+                object_api._append_bulk(
+                    tag_api=tag_api,
+                    entity_id=video_id,
+                    project_id=project_id,
+                    dataset_id=dataset_id,
+                    objects=new_objects,
+                    key_id_map=key_id_map,
+                    is_pointcloud=False,
+                    is_video_multi_view=True,
+                )
+            tags_to_obj = {}
+            for obj in ann.objects:
+                obj_id = key_id_map.get_object_id(obj.key())
+                tags_to_obj[obj_id] = obj.tags
+            if len(tags_to_obj) > 0:
+                tag_api.add_tags_collection_to_objects(project_id, tags_to_obj, is_video_multi_view=True, entity_id=video_id)
+
+            figure_api.append_bulk(video_id, ann.figures, key_id_map)
+            if progress_cb is not None and len(ann.figures) > 0:
+                if hasattr(progress_cb, "update") and callable(getattr(progress_cb, "update")):
+                    progress_cb.update(len(ann.figures))
+                else:
+                    progress_cb(len(ann.figures))
+
     def copy_batch(
         self,
         src_video_ids: List[int],
@@ -236,11 +350,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,8 +5,10 @@ import asyncio
 import datetime
 import json
 import os
+import re
 import urllib.parse
 from functools import partial
+from itertools import zip_longest
 from typing import (
     AsyncGenerator,
     Callable,
@@ -23,7 +25,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
@@ -46,6 +52,7 @@ from supervisely.io.fs import (
     get_file_hash,
     get_file_hash_async,
     get_file_hash_chunked,
+    get_file_hash_chunked_async,
     get_file_name_with_ext,
     get_file_size,
     list_files,
@@ -700,7 +707,7 @@ class VideoApi(RemoveableBulkModuleApi):
         return project_id, dataset_id
 
     def upload_hash(
-        self, dataset_id: int, name: str, hash: str, stream_index: Optional[int] = None
+        self, dataset_id: int, name: str, hash: str, stream_index: Optional[int] = None, metadata: Optional[Dict] = None
     ) -> VideoInfo:
         """
         Upload Video from given hash to Dataset.
@@ -713,6 +720,8 @@ class VideoApi(RemoveableBulkModuleApi):
         :type hash: str
         :param stream_index: Index of video stream.
         :type stream_index: int, optional
+        :param metadata: Video metadata.
+        :type metadata: dict, optional
         :return: Information about Video. See :class:`info_sequence<info_sequence>`
         :rtype: :class:`VideoInfo`
         :Usage example:
@@ -781,6 +790,8 @@ class VideoApi(RemoveableBulkModuleApi):
         meta = {}
         if stream_index is not None and type(stream_index) is int:
             meta = {"videoStreamIndex": stream_index}
+        if metadata is not None:
+            meta.update(metadata)
         return self.upload_hashes(dataset_id, [name], [hash], [meta])[0]
 
     def upload_hashes(
@@ -1106,10 +1117,10 @@ class VideoApi(RemoveableBulkModuleApi):
             validate_ext(os.path.splitext(name)[1])
 
         for batch in batched(list(zip(names, items, metas))):
-            images = []
+            videos = []
             for name, item, meta in batch:
                 item_tuple = func_item_to_kv(item)
-                images.append(
+                videos.append(
                     {
                         "title": name,
                         item_tuple[0]: item_tuple[1],
@@ -1120,12 +1131,12 @@ class VideoApi(RemoveableBulkModuleApi):
                 "videos.bulk.add",
                 {
                     ApiField.DATASET_ID: dataset_id,
-                    ApiField.VIDEOS: images,
+                    ApiField.VIDEOS: videos,
                     ApiField.FORCE_METADATA_FOR_LINKS: force_metadata_for_links,
                 },
             )
             if progress_cb is not None:
-                progress_cb(len(images))
+                progress_cb(len(videos))
 
             results = [self._convert_json_info(item) for item in response.json()]
             name_to_res = {img_info.name: img_info for img_info in results}
@@ -1186,6 +1197,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,
@@ -1536,15 +1582,20 @@ class VideoApi(RemoveableBulkModuleApi):
         for hash_value, meta in zip(unique_hashes, unique_metas):
             hash_meta_dict[hash_value] = meta
 
-        metas = [hash_meta_dict[hash_value] for hash_value in hashes]
-
-        metas2 = [meta["meta"] for meta in metas]
-
+        video_metadatas = [hash_meta_dict[hash_value] for hash_value in hashes]
+        video_metadatas2 = [meta["meta"] for meta in video_metadatas]
         names = self.get_free_names(dataset_id, names)
 
-        for name, hash, meta in zip(names, hashes, metas2):
+        if metas is None:
+            metas = [None] * len(names)
+        if not isinstance(metas, list):
+            raise ValueError("metas must be a list")
+
+        for name, hash, video_metadata, metadata in zip_longest(
+            names, hashes, video_metadatas2, metas
+        ):
             try:
-                all_streams = meta["streams"]
+                all_streams = video_metadata["streams"]
                 video_streams = get_video_streams(all_streams)
                 for stream_info in video_streams:
                     stream_index = stream_info["index"]
@@ -1559,7 +1610,7 @@ class VideoApi(RemoveableBulkModuleApi):
                     # info = self._api.video.get_info_by_name(dataset_id, item_name)
                     # if info is not None:
                     #     item_name = gen_video_stream_name(name, stream_index)
-                    res = self.upload_hash(dataset_id, name, hash, stream_index)
+                    res = self.upload_hash(dataset_id, name, hash, stream_index, metadata)
                     video_info_results.append(res)
             except Exception as e:
                 from supervisely.io.exception_handlers import (
@@ -2531,7 +2582,7 @@ class VideoApi(RemoveableBulkModuleApi):
                         progress_cb(len(chunk))
             if check_hash:
                 if hash_to_check is not None:
-                    downloaded_file_hash = await get_file_hash_async(path)
+                    downloaded_file_hash = await get_file_hash_chunked_async(path)
                     if hash_to_check != downloaded_file_hash:
                         raise RuntimeError(
                             f"Downloaded hash of video with ID:{id} does not match the expected hash: {downloaded_file_hash} != {hash_to_check}"

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,12 +11,14 @@ import threading
 import time
 import traceback
 from concurrent.futures import ThreadPoolExecutor
+from typing import Optional, Union
 
 import jsonpatch
 from fastapi import Request
 
 from supervisely._utils import is_production
 from supervisely.api.api import Api
+import supervisely.app.fastapi.multi_user as multi_user
 from supervisely.app.fastapi import run_sync
 from supervisely.app.fastapi.websocket import WebsocketManager
 from supervisely.app.singleton import Singleton
@@ -109,16 +111,29 @@ 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))
+        if user_id is not None:
+            async with multi_user.async_session_context(user_id):
+                await self._apply_patch(patch)
+                await self._ws.broadcast(
+                    self.get_changes(patch), user_id=user_id
+                )
+        else:
+            await self._apply_patch(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 +154,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 +164,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/development/development.py

@@ -156,7 +156,10 @@ def supervisely_vpn_network(
 
 
 def create_debug_task(
-    team_id: int = None, port: int = 8000, update_status: bool = True
+    team_id: int = None,
+    port: int = 8000,
+    update_status: bool = True,
+    project_id: Optional[int] = None,
 ) -> Dict[str, Any]:
     """Gets or creates a debug task for the current user.
 
@@ -167,6 +170,8 @@ def create_debug_task(
     :type port: int
     :param update_status: If True, the task status will be updated to STARTED.
     :type update_status: bool
+    :param project_id: Project ID to filter existing debug tasks. Creates a new task if no match is found. Default is None.
+    :type project_id: Optional[int]
     :return: The task details.
     :rtype: Dict[str, Any]
     """
@@ -189,6 +194,10 @@ def create_debug_task(
         if (session.details["meta"].get("redirectRequests") == redirect_requests) and (
             session.details["status"] in [str(api.app.Status.QUEUED), str(api.app.Status.STARTED)]
         ):
+            if project_id is not None:
+                state = session.details["meta"].get("params", {}).get("state", {})
+                if state.get("slyProjectId") != project_id:
+                    continue  # project_id not set in state, skip this session
             task = session.details
             if "id" not in task:
                 task["id"] = task["taskId"]
@@ -196,6 +205,7 @@ def create_debug_task(
             break
     workspaces = api.workspace.get_list(team_id)
     if task is None:
+        params = {"state": {"slyProjectId": project_id}} if project_id is not None else None
         task = api.task.start(
             agent_id=None,
             module_id=module_id,
@@ -203,6 +213,7 @@ def create_debug_task(
             task_name=session_name,
             redirect_requests=redirect_requests,
             proxy_keep_url=False,  # to ignore /net/<token>/endpoint
+            params=params,
         )
         if type(task) is list:
             task = task[0]
@@ -222,6 +233,7 @@ def enable_advanced_debug(
     vpn_action: Literal["up", "down"] = "up",
     vpn_raise_on_error: bool = True,
     only_for_development: bool = True,
+    project_id: Optional[int] = None,
 ) -> Optional[int]:
     """Enables advanced debugging for the app.
     At first, it establishes a WireGuard VPN connection to the Supervisely network.
@@ -244,6 +256,8 @@ def enable_advanced_debug(
     :param only_for_development: If True, the debugging will be started only if the app is running in development mode.
         It's not recommended to set this parameter to False in production environments.
     :type only_for_development: bool
+    :param project_id: Project ID to filter existing debug tasks. Creates a new task if no match is found. Default is None.
+    :type project_id: Optional[int]
     :return: The task ID of the debug task or None if the debugging was not started.
     :rtype: Optional[int]
 
@@ -285,7 +299,9 @@ def enable_advanced_debug(
     )
 
     supervisely_vpn_network(action=vpn_action, raise_on_error=vpn_raise_on_error)
-    task = create_debug_task(team_id=team_id, port=port, update_status=update_status)
+    task = create_debug_task(
+        team_id=team_id, port=port, update_status=update_status, project_id=project_id
+    )
     task_id = task.get("id", None)
 
     logger.debug(

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/custom_static_files.py

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