supervisely 6.73.284__py3-none-any.whl → 6.73.286__py3-none-any.whl

supervisely/__init__.py

@@ -311,4 +311,4 @@ except Exception as e:
 # If new changes in Supervisely Python SDK require upgrade of the Supervisely instance
 # set a new value for the environment variable MINIMUM_INSTANCE_VERSION_FOR_SDK, otherwise
 # users can face compatibility issues, if the instance version is lower than the SDK version.
-os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.17"
+os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.23"

supervisely/_utils.py

@@ -83,6 +83,15 @@ def take_with_default(v, default):
     return v if v is not None else default
 
 
+def find_value_by_keys(d: Dict, keys: List[str], default=object()):
+    for key in keys:
+        if key in d:
+            return d[key]
+    if default is object():
+        raise KeyError(f"None of the keys {keys} are in the dictionary.")
+    return default
+
+
 def batched(seq, batch_size=50):
     for i in range(0, len(seq), batch_size):
         yield seq[i : i + batch_size]

supervisely/api/entity_annotation/figure_api.py

@@ -81,6 +81,9 @@ class FigureInfo(NamedTuple):
         if self.geometry_meta is not None:
             return Rectangle(*self.geometry_meta["bbox"], sly_id=self.id)
 
+    def to_json(self):
+        return FigureApi.convert_info_to_json(self)
+
 
 class FigureApi(RemoveableBulkModuleApi):
     """

supervisely/api/module_api.py

@@ -3,7 +3,16 @@ import asyncio
 from collections import namedtuple
 from copy import deepcopy
 from math import ceil
-from typing import TYPE_CHECKING, Any, AsyncGenerator, List, NamedTuple, Optional, Tuple
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    Dict,
+    List,
+    NamedTuple,
+    Optional,
+    Tuple,
+)
 
 import requests
 
@@ -602,6 +611,8 @@ class ApiField:
     """"""
     WITH_SHARED = "withShared"
     """"""
+    USE_DIRECT_PROGRESS_MESSAGES = "useDirectProgressMessages"
+    """"""
     EXTRA_FIELDS = "extraFields"
     """"""
     CUSTOM_SORT = "customSort"
@@ -861,6 +872,29 @@ class ModuleApiBase(_JsonConvertibleModule):
                     raise RuntimeError("Can not parse field {!r}".format(field_name))
             return self.InfoType(*field_values)
 
+    @classmethod
+    def convert_info_to_json(cls, info: NamedTuple) -> Dict:
+        """_convert_info_to_json"""
+
+        def _create_nested_dict(keys, value):
+            if len(keys) == 1:
+                return {keys[0]: value}
+            else:
+                return {keys[0]: _create_nested_dict(keys[1:], value)}
+
+        json_info = {}
+        for field_name, value in zip(cls.info_sequence(), info):
+            if type(field_name) is str:
+                json_info[field_name] = value
+            elif isinstance(field_name, tuple):
+                if len(field_name[0]) == 0:
+                    json_info[field_name[1]] = value
+                else:
+                    json_info.update(_create_nested_dict(field_name[0], value))
+            else:
+                raise RuntimeError("Can not parse field {!r}".format(field_name))
+        return json_info
+
     def _get_response_by_id(self, id, method, id_field, fields=None):
         """_get_response_by_id"""
         try:

supervisely/api/video/video_api.py

@@ -1361,7 +1361,7 @@ class VideoApi(RemoveableBulkModuleApi):
         :return: None
         """
 
-        response = self._api.post(
+        self._api.post(
             "videos.notify-annotation-tool",
             {
                 "type": "videos:tracking-error",

supervisely/api/video_annotation_tool_api.py

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 from supervisely.api.module_api import ApiField, ModuleApiBase
 from supervisely.collection.str_enum import StrEnum
@@ -21,6 +21,7 @@ class VideoAnnotationToolAction(StrEnum):
     """"""
     ENTITIES_SET_INTITY = "entities/setEntity"
     """"""
+    DIRECT_TRACKING_PROGRESS = "figures/setDirectTrackingProgress"
 
 
 class VideoAnnotationToolApi(ModuleApiBase):
@@ -51,7 +52,7 @@ class VideoAnnotationToolApi(ModuleApiBase):
             VideoAnnotationToolAction.JOBS_ENABLE_CONTROLS,
             {},
         )
-        
+
     def disable_submit_button(self, session_id: str) -> Dict[str, Any]:
         """Disables submit button of the labeling jobs.
 
@@ -65,7 +66,7 @@ class VideoAnnotationToolApi(ModuleApiBase):
             VideoAnnotationToolAction.JOBS_DISABLE_SUBMIT,
             {},
         )
-        
+
     def enable_submit_button(self, session_id: str) -> Dict[str, Any]:
         """Enables submit button of the labeling jobs.
 
@@ -79,7 +80,7 @@ class VideoAnnotationToolApi(ModuleApiBase):
             VideoAnnotationToolAction.JOBS_ENABLE_SUBMIT,
             {},
         )
-        
+
     def disable_confirm_button(self, session_id: str) -> Dict[str, Any]:
         """Disables confirm button of the labeling jobs.
 
@@ -93,10 +94,10 @@ class VideoAnnotationToolApi(ModuleApiBase):
             VideoAnnotationToolAction.JOBS_DISABLE_CONFIRM,
             {},
         )
-    
+
     def enable_confirm_button(self, session_id: str) -> Dict[str, Any]:
         """Enables confirm button of the labeling jobs.
-        
+
         :param session_id: ID of the session in the Video Labeling Tool which confirm button should be enabled.
         :type session_id: str
         :return: Response from API server in JSON format.
@@ -132,12 +133,62 @@ class VideoAnnotationToolApi(ModuleApiBase):
             },
         )
 
+    def set_direct_tracking_progress(
+        self,
+        session_id: str,
+        video_id: int,
+        track_id: str,
+        frame_range: Tuple,
+        progress_current: int,
+        progress_total: int,
+    ):
+        payload = {
+            ApiField.TRACK_ID: track_id,
+            ApiField.VIDEO_ID: video_id,
+            ApiField.FRAME_RANGE: frame_range,
+            ApiField.PROGRESS: {
+                ApiField.CURRENT: progress_current,
+                ApiField.TOTAL: progress_total,
+            },
+        }
+        return self._act(session_id, VideoAnnotationToolAction.DIRECT_TRACKING_PROGRESS, payload)
+
+    def set_direct_tracking_error(
+        self,
+        session_id: str,
+        video_id: int,
+        track_id: str,
+        message: str,
+    ):
+        payload = {
+            ApiField.TRACK_ID: track_id,
+            ApiField.VIDEO_ID: video_id,
+            ApiField.TYPE: "error",
+            ApiField.ERROR: {ApiField.MESSAGE: message},
+        }
+        return self._act(session_id, VideoAnnotationToolAction.DIRECT_TRACKING_PROGRESS, payload)
+
+    def set_direct_tracking_warning(
+        self,
+        session_id: str,
+        video_id: int,
+        track_id: str,
+        message: str,
+    ):
+        payload = {
+            ApiField.TRACK_ID: track_id,
+            ApiField.VIDEO_ID: video_id,
+            ApiField.TYPE: "warning",
+            ApiField.MESSAGE: message,
+        }
+        return self._act(session_id, VideoAnnotationToolAction.DIRECT_TRACKING_PROGRESS, payload)
+
     def _act(self, session_id: int, action: VideoAnnotationToolAction, payload: dict):
         data = {
             ApiField.SESSION_ID: session_id,
             ApiField.ACTION: str(action),
             ApiField.PAYLOAD: payload,
         }
-        resp = self._api.post("/annotation-tool.run-action", data)
+        resp = self._api.post("annotation-tool.run-action", data)
 
         return resp.json()

supervisely/app/fastapi/subapp.py

@@ -926,19 +926,20 @@ class Application(metaclass=Singleton):
         self.test_client = TestClient(self._fastapi)
 
         if not headless:
-            templates = Jinja2Templates()
-            self.hot_reload = arel.HotReload([])
-            self._fastapi.add_websocket_route(
-                "/hot-reload", route=self.hot_reload, name="hot-reload"
-            )
-            self._fastapi.add_event_handler("startup", self.hot_reload.startup)
-            self._fastapi.add_event_handler("shutdown", self.hot_reload.shutdown)
+            if is_development() and hot_reload:
+                templates = Jinja2Templates()
+                self.hot_reload = arel.HotReload([])
+                self._fastapi.add_websocket_route(
+                    "/hot-reload", route=self.hot_reload, name="hot-reload"
+                )
+                self._fastapi.add_event_handler("startup", self.hot_reload.startup)
+                self._fastapi.add_event_handler("shutdown", self.hot_reload.shutdown)
 
-            # Setting HOTRELOAD=1 in template context, otherwise the HTML would not have the hot reload script.
-            templates.env.globals["HOTRELOAD"] = "1"
-            templates.env.globals["hot_reload"] = self.hot_reload
+                # Setting HOTRELOAD=1 in template context, otherwise the HTML would not have the hot reload script.
+                templates.env.globals["HOTRELOAD"] = "1"
+                templates.env.globals["hot_reload"] = self.hot_reload
 
-            logger.debug("Hot reload is enabled, use app.reload_page() to reload page.")
+                logger.debug("Hot reload is enabled, use app.reload_page() to reload page.")
 
             if is_production():
                 # to save offline session

supervisely/nn/inference/cache.py

@@ -303,6 +303,22 @@ class InferenceImageCache:
                 self.get_frame_from_cache(video_id, frame_index) for frame_index in frame_indexes
             ]
 
+    def frames_loader(
+        self, api: sly.Api, video_id: int, frame_indexes: List[int]
+    ) -> Generator[np.ndarray, None, None]:
+        if not isinstance(self._cache, PersistentImageTTLCache):
+            for frame_index in frame_indexes:
+                yield self.download_frame(api, video_id, frame_index)
+            return
+        self.run_cache_task_manually(api, None, video_id=video_id)
+        for i, frame_index in enumerate(frame_indexes):
+            if video_id in self._cache:
+                break
+            yield self.download_frame(api, video_id, frame_index)
+        if i < len(frame_indexes):
+            for frame in self._read_frames_from_cached_video_iter(video_id, frame_indexes[i:]):
+                yield frame
+
     def download_frame(self, api: sly.Api, video_id: int, frame_index: int) -> np.ndarray:
         name = self._frame_name(video_id, frame_index)
         self._wait_if_in_queue(name, api.logger)
@@ -401,7 +417,9 @@ class InferenceImageCache:
         """
         return_images = kwargs.get("return_images", True)
         progress_cb = kwargs.get("progress_cb", None)
-        video_info = kwargs.get("video_info", api.video.get_info_by_id(video_id))
+        video_info = kwargs.get("video_info", None)
+        if video_info is None:
+            video_info = api.video.get_info_by_id(video_id)
 
         self._wait_if_in_queue(video_id, api.logger)
         if not video_id in self._cache:

supervisely/nn/inference/inference.py

@@ -2252,6 +2252,25 @@ class Inference:
     def is_model_deployed(self):
         return self._model_served
 
+    def schedule_task(self, func, *args, **kwargs):
+        inference_request_uuid = kwargs.get("inference_request_uuid", None)
+        if inference_request_uuid is None:
+            self._executor.submit(func, *args, **kwargs)
+        else:
+            self._on_inference_start(inference_request_uuid)
+            future = self._executor.submit(
+                self._handle_error_in_async,
+                inference_request_uuid,
+                func,
+                *args,
+                **kwargs,
+            )
+            end_callback = partial(
+                self._on_inference_end, inference_request_uuid=inference_request_uuid
+            )
+            future.add_done_callback(end_callback)
+        logger.debug("Scheduled task.", extra={"inference_request_uuid": inference_request_uuid})
+
     def serve(self):
         if not self._use_gui:
             Progress("Deploying model ...", 1)
@@ -2320,6 +2339,9 @@ class Inference:
         else:
             autostart_func()
 
+        self.cache.add_cache_endpoint(server)
+        self.cache.add_cache_files_endpoint(server)
+
         @server.post(f"/get_session_info")
         @self._check_serve_before_call
         def get_session_info(response: Response):
@@ -2632,6 +2654,7 @@ class Inference:
 
             # Ger rid of `pending_results` to less response size
             inference_request["pending_results"] = []
+            inference_request.pop("lock", None)
             return inference_request
 
         @server.post(f"/pop_inference_results")