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

supervisely/__init__.py

@@ -8,6 +8,22 @@ try:
 except TypeError as e:
     __version__ = "development"
 
+
+class _ApiProtoNotAvailable:
+    """Placeholder class that raises an error when accessing any attribute"""
+
+    def __getattr__(self, name):
+        from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+        raise ImportError(f"Cannot access `api_proto.{name}` : " + PROTOBUF_REQUIRED_ERROR)
+
+    def __bool__(self):
+        return False
+
+    def __repr__(self):
+        return "<api_proto: not available - install supervisely[agent] to enable>"
+
+
 from supervisely.sly_logger import (
     logger,
     ServiceType,
@@ -112,7 +128,14 @@ from supervisely.worker_api.chunking import (
     ChunkedFileWriter,
     ChunkedFileReader,
 )
-import supervisely.worker_proto.worker_api_pb2 as api_proto
+
+# Global import of api_proto works only if protobuf is installed and compatible
+# Otherwise, we use a placeholder that raises an error when accessed
+try:
+    import supervisely.worker_proto.worker_api_pb2 as api_proto
+except Exception:
+    api_proto = _ApiProtoNotAvailable()
+
 
 from supervisely.api.api import Api, UserSession, ApiContext
 from supervisely.api import api

supervisely/_utils.py

@@ -319,6 +319,87 @@ def resize_image_url(
         return full_storage_url
 
 
+def get_storage_url(
+    entity_type: Literal["dataset-entities", "dataset", "project", "file-storage"],
+    entity_id: int,
+    source_type: Literal["original", "preview"],
+) -> str:
+    """
+    Generate URL for storage resources endpoints.
+
+    :param entity_type: Type of entity ("dataset-entities", "dataset", "project", "file-storage")
+    :type entity_type: str
+    :param entity_id: ID of the entity
+    :type entity_id: int
+    :param source_type: Type of source ("original" or "preview")
+    :type source_type: Literal["original", "preview"]
+    :return: Storage URL
+    :rtype: str
+    """
+    relative_url = f"/storage-resources/{entity_type}/{source_type}/{entity_id}"
+    if is_development():
+        return abs_url(relative_url)
+    return relative_url
+
+
+def get_image_storage_url(image_id: int, source_type: Literal["original", "preview"]) -> str:
+    """
+    Generate URL for image storage resources.
+
+    :param image_id: ID of the image
+    :type image_id: int
+    :param source_type: Type of source ("original" or "preview")
+    :type source_type: Literal["original", "preview"]
+    :return: Storage URL for image
+    :rtype: str
+    """
+    return get_storage_url("dataset-entities", image_id, source_type)
+
+
+def get_dataset_storage_url(
+    dataset_id: int, source_type: Literal["original", "preview", "raw"]
+) -> str:
+    """
+    Generate URL for dataset storage resources.
+
+    :param dataset_id: ID of the dataset
+    :type dataset_id: int
+    :param source_type: Type of source ("original", "preview", or "raw")
+    :type source_type: Literal["original", "preview", "raw"]
+    :return: Storage URL for dataset
+    :rtype: str
+    """
+    return get_storage_url("dataset", dataset_id, source_type)
+
+
+def get_project_storage_url(
+    project_id: int, source_type: Literal["original", "preview", "raw"]
+) -> str:
+    """
+    Generate URL for project storage resources.
+
+    :param project_id: ID of the project
+    :type project_id: int
+    :param source_type: Type of source ("original", "preview", or "raw")
+    :type source_type: Literal["original", "preview", "raw"]
+    :return: Storage URL for project
+    :rtype: str
+    """
+    return get_storage_url("project", project_id, source_type)
+
+
+def get_file_storage_url(file_id: int) -> str:
+    """
+    Generate URL for file storage resources (raw files).
+
+    :param file_id: ID of the file
+    :type file_id: int
+    :return: Storage URL for file
+    :rtype: str
+    """
+    return get_storage_url("file-storage", file_id, "raw")
+
+
 def get_preview_link(title="preview"):
     return (
         f'<a href="javascript:;">{title}<i class="zmdi zmdi-cast" style="margin-left: 5px"></i></a>'

supervisely/annotation/json_geometries_map.py

@@ -15,6 +15,7 @@ from supervisely.geometry.multichannel_bitmap import MultichannelBitmap
 from supervisely.geometry.closed_surface_mesh import ClosedSurfaceMesh
 from supervisely.geometry.alpha_mask import AlphaMask
 from supervisely.geometry.cuboid_2d import Cuboid2d
+from supervisely.geometry.polyline_3d import Polyline3D
 
 
 _INPUT_GEOMETRIES = [
@@ -34,6 +35,7 @@ _INPUT_GEOMETRIES = [
     ClosedSurfaceMesh,
     AlphaMask,
     Cuboid2d,
+    Polyline3D,
 ]
 _JSON_SHAPE_TO_GEOMETRY_TYPE = {
     geometry.geometry_name(): geometry for geometry in _INPUT_GEOMETRIES

supervisely/api/dataset_api.py

@@ -1021,13 +1021,66 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
 
         return dataset_tree
 
-    def tree(self, project_id: int) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
+    def _yield_tree(
+        self, tree: Dict[DatasetInfo, Dict], path: List[str]
+    ) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
+        """
+        Helper method for recursive tree traversal.
+        Yields tuples of (path, dataset) for all datasets in the tree. For each node (dataset) at the current level,
+        yields its (path, dataset) before recursively traversing and yielding from its children.
+        
+        :param tree: Tree structure to yield from.
+        :type tree: Dict[DatasetInfo, Dict]
+        :param path: Current path (used for recursion).
+        :type path: List[str]
+        :return: Generator of tuples of (path, dataset).
+        :rtype: Generator[Tuple[List[str], DatasetInfo], None, None]
+        """
+        for dataset, children in tree.items():
+            yield path, dataset
+            new_path = path + [dataset.name]
+            if children:
+                yield from self._yield_tree(children, new_path)
+
+    def _find_dataset_in_tree(
+        self, tree: Dict[DatasetInfo, Dict], target_id: int, path: List[str] = None
+    ) -> Tuple[Optional[DatasetInfo], Optional[Dict], List[str]]:
+        """Find a specific dataset in the tree and return its subtree and path.
+        
+        :param tree: Tree structure to search in.
+        :type tree: Dict[DatasetInfo, Dict]
+        :param target_id: ID of the dataset to find.
+        :type target_id: int
+        :param path: Current path (used for recursion).
+        :type path: List[str], optional
+        :return: Tuple of (found_dataset, its_subtree, path_to_dataset).
+        :rtype: Tuple[Optional[DatasetInfo], Optional[Dict], List[str]]
+        """
+        if path is None:
+            path = []
+            
+        for dataset, children in tree.items():
+            if dataset.id == target_id:
+                return dataset, children, path
+            # Search in children
+            if children:
+                found_dataset, found_children, found_path = self._find_dataset_in_tree(
+                    children, target_id, path + [dataset.name]
+                )
+                if found_dataset is not None:
+                    return found_dataset, found_children, found_path
+        return None, None, []
+
+    def tree(self, project_id: int, dataset_id: Optional[int] = None) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
         """Yields tuples of (path, dataset) for all datasets in the project.
         Path of the dataset is a list of parents, e.g. ["ds1", "ds2", "ds3"].
         For root datasets, the path is an empty list.
 
         :param project_id: Project ID in which the Dataset is located.
         :type project_id: int
+        :param dataset_id: Optional Dataset ID to start the tree from. If provided, only yields
+            the subtree starting from this dataset (including the dataset itself and all its children).
+        :type dataset_id: Optional[int]
         :return: Generator of tuples of (path, dataset).
         :rtype: Generator[Tuple[List[str], DatasetInfo], None, None]
         :Usage example:
@@ -1040,11 +1093,17 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
 
             project_id = 123
 
+            # Get all datasets in the project
             for parents, dataset in api.dataset.tree(project_id):
                 parents: List[str]
                 dataset: sly.DatasetInfo
                 print(parents, dataset.name)
 
+            # Get only a specific branch starting from dataset_id = 456
+            for parents, dataset in api.dataset.tree(project_id, dataset_id=456):
+                parents: List[str]
+                dataset: sly.DatasetInfo
+                print(parents, dataset.name)
 
             # Output:
             # [] ds1
@@ -1052,17 +1111,20 @@ class DatasetApi(UpdateableModule, RemoveableModuleApi):
             # ["ds1", "ds2"] ds3
         """
 
-        def yield_tree(
-            tree: Dict[DatasetInfo, Dict], path: List[str]
-        ) -> Generator[Tuple[List[str], DatasetInfo], None, None]:
-            """Yields tuples of (path, dataset) for all datasets in the tree."""
-            for dataset, children in tree.items():
-                yield path, dataset
-                new_path = path + [dataset.name]
-                if children:
-                    yield from yield_tree(children, new_path)
-
-        yield from yield_tree(self.get_tree(project_id), [])
+        full_tree = self.get_tree(project_id)
+        
+        if dataset_id is None:
+            # Return the full tree
+            yield from self._yield_tree(full_tree, [])
+        else:
+            # Find the specific dataset and return only its subtree
+            target_dataset, subtree, dataset_path = self._find_dataset_in_tree(full_tree, dataset_id)
+            if target_dataset is not None:
+                # Yield the target dataset first, then its children
+                yield dataset_path, target_dataset
+                if subtree:
+                    new_path = dataset_path + [target_dataset.name]
+                    yield from self._yield_tree(subtree, new_path)
 
     def get_nested(self, project_id: int, dataset_id: int) -> List[DatasetInfo]:
         """Returns a list of all nested datasets in the specified dataset.

supervisely/api/entity_annotation/figure_api.py

@@ -24,10 +24,10 @@ from requests_toolbelt import MultipartDecoder, MultipartEncoder
 from tqdm import tqdm
 
 from supervisely._utils import batched, logger, run_coroutine
+from supervisely.annotation.label import LabelingStatus
 from supervisely.api.module_api import ApiField, ModuleApi, RemoveableBulkModuleApi
 from supervisely.geometry.rectangle import Rectangle
 from supervisely.video_annotation.key_id_map import KeyIdMap
-from supervisely.annotation.label import LabelingStatus
 
 
 class FigureInfo(NamedTuple):
@@ -595,10 +595,13 @@ class FigureApi(RemoveableBulkModuleApi):
         """
         geometries = {}
         for idx, part in self._download_geometries_generator(ids):
-            if progress_cb is not None:
-                progress_cb(len(part.content))
-            geometry_json = json.loads(part.content)
-            geometries[idx] = geometry_json
+            try:
+                if progress_cb is not None:
+                    progress_cb(len(part.content))
+                geometry_json = json.loads(part.content)
+                geometries[idx] = geometry_json
+            except Exception as e:
+                raise RuntimeError(f"Failed to decode geometry for figure ID {idx}") from e
 
         if len(geometries) != len(ids):
             raise RuntimeError("Not all geometries were downloaded")

supervisely/api/image_api.py

@@ -397,6 +397,9 @@ class ImageInfo(NamedTuple):
     #: Format: "YYYY-MM-DDTHH:MM:SS.sssZ"
     embeddings_updated_at: Optional[str] = None
 
+    #: :class:`int`: :class:`Dataset<supervisely.project.project.Project>` ID in Supervisely.
+    project_id: int = None
+
     # DO NOT DELETE THIS COMMENT
     #! New fields must be added with default values to keep backward compatibility.
 
@@ -476,6 +479,7 @@ class ImageApi(RemoveableBulkModuleApi):
             ApiField.OFFSET_END,
             ApiField.AI_SEARCH_META,
             ApiField.EMBEDDINGS_UPDATED_AT,
+            ApiField.PROJECT_ID,
         ]
 
     @staticmethod

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,

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/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})",
                 )
 

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)