supervisely 6.73.284__tar.gz → 6.73.285__tar.gz

{supervisely-6.73.284/supervisely.egg-info → supervisely-6.73.285}/PKG-INFO

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

{supervisely-6.73.284 → supervisely-6.73.285}/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-6.73.284 → supervisely-6.73.285}/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-6.73.284 → supervisely-6.73.285}/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-6.73.284 → supervisely-6.73.285}/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-6.73.284 → supervisely-6.73.285}/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-6.73.284 → supervisely-6.73.285}/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-6.73.284 → supervisely-6.73.285}/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):

supervisely-6.73.285/supervisely/nn/inference/tracking/base_tracking.py

@@ -0,0 +1,362 @@
+import functools
+import inspect
+import json
+import traceback
+from threading import Lock
+from typing import Any, BinaryIO, Dict, List, Optional, Tuple, Union
+
+from fastapi import Form, Request, Response, UploadFile, status
+from pydantic import ValidationError
+
+from supervisely._utils import find_value_by_keys
+from supervisely.api.api import Api
+from supervisely.api.module_api import ApiField
+from supervisely.io import env
+from supervisely.nn.inference.inference import (
+    Inference,
+    _convert_sly_progress_to_dict,
+    _get_log_extra_for_inference_request,
+)
+from supervisely.sly_logger import logger
+
+
+def validate_key(data: Dict, key: str, type_: type):
+    if key not in data:
+        raise ValidationError(f"Key {key} not found in inference request.")
+    if not isinstance(data[key], type_):
+        raise ValidationError(f"Key {key} is not of type {type_}.")
+
+
+def handle_validation(func):
+    def _find_response(args, kwargs):
+        for arg in args:
+            if isinstance(arg, Response):
+                return arg
+        for value in kwargs.values():
+            if isinstance(value, Response):
+                return value
+        return None
+
+    def _handle_exception(e, response):
+        if response is not None:
+            logger.error(f"ValidationError: {e}", exc_info=True)
+            response.status_code = status.HTTP_400_BAD_REQUEST
+            return {"error": str(e), "success": False}
+        raise e
+
+    if inspect.iscoroutinefunction(func):
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            response = _find_response(args, kwargs)
+            try:
+                return await func(*args, **kwargs)
+            except ValidationError as e:
+                return _handle_exception(e, response)
+
+        return async_wrapper
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        response = _find_response(args, kwargs)
+        try:
+            return func(*args, **kwargs)
+        except ValidationError as e:
+            return _handle_exception(e, response)
+
+    return wrapper
+
+
+class BaseTracking(Inference):
+    def __init__(
+        self,
+        model_dir: Optional[str] = None,
+        custom_inference_settings: Optional[Union[Dict[str, Any], str]] = None,
+    ):
+        Inference.__init__(
+            self,
+            model_dir,
+            custom_inference_settings,
+            sliding_window_mode=None,
+            use_gui=False,
+        )
+
+        try:
+            self.load_on_device(model_dir, "cuda")
+        except RuntimeError:
+            self.load_on_device(model_dir, "cpu")
+            logger.warning("Failed to load model on CUDA device.")
+
+        logger.debug(
+            "Smart cache params",
+            extra={"ttl": env.smart_cache_ttl(), "maxsize": env.smart_cache_size()},
+        )
+
+    def get_info(self):
+        info = super().get_info()
+        info["task type"] = "tracking"
+        return info
+
+    def _on_inference_start(self, inference_request_uuid: str):
+        super()._on_inference_start(inference_request_uuid)
+        self._inference_requests[inference_request_uuid]["lock"] = Lock()
+
+    @staticmethod
+    def _notify_error_default(
+        api: Api, track_id: str, exception: Exception, with_traceback: bool = False
+    ):
+        error_name = type(exception).__name__
+        message = str(exception)
+        if with_traceback:
+            message = f"{message}\n{traceback.format_exc()}"
+        api.video.notify_tracking_error(track_id, error_name, message)
+
+    @staticmethod
+    def _notify_error_direct(
+        api: Api,
+        session_id: str,
+        video_id,
+        track_id: str,
+        exception: Exception,
+        with_traceback: bool = False,
+    ):
+        error_name = type(exception).__name__
+        message = str(exception)
+        if with_traceback:
+            message = f"{message}\n{traceback.format_exc()}"
+        api.vid_ann_tool.set_direct_tracking_error(
+            session_id=session_id,
+            video_id=video_id,
+            track_id=track_id,
+            message=f"{error_name}: {message}",
+        )
+
+    def _handle_error_in_async(self, uuid):
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    inf_request = self._inference_requests.get(uuid, None)
+                    if inf_request is not None:
+                        inf_request["exception"] = str(e)
+                    logger.error(f"Error in {func.__name__} function: {e}", exc_info=True)
+                    raise e
+
+            return wrapper
+
+        return decorator
+
+    @staticmethod
+    def send_error_data(api, context):
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as exc:
+                    try:
+                        track_id = context["trackId"]
+                        if ApiField.USE_DIRECT_PROGRESS_MESSAGES in context:
+                            session_id = find_value_by_keys(context, ["sessionId", "session_id"])
+                            video_id = find_value_by_keys(context, ["videoId", "video_id"])
+                            BaseTracking._notify_error_direct(
+                                api=api,
+                                session_id=session_id,
+                                video_id=video_id,
+                                track_id=track_id,
+                                exception=exc,
+                                with_traceback=False,
+                            )
+                        else:
+                            BaseTracking._notify_error_default(
+                                api=api, track_id=track_id, exception=exc, with_traceback=False
+                            )
+                    except Exception:
+                        logger.error("An error occurred while sending error data", exc_info=True)
+                    raise exc
+
+            return wrapper
+
+        return decorator
+
+    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)
+            fn = self._handle_error_in_async(inference_request_uuid)(func)
+            future = self._executor.submit(
+                fn,
+                *args,
+                **kwargs,
+            )
+            end_callback = functools.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 _pop_tracking_results(self, inference_request_uuid: str, frame_range: Tuple = None):
+        inference_request = self._inference_requests[inference_request_uuid]
+        logger.debug(
+            "Pop tracking results",
+            extra={
+                "inference_request_uuid": inference_request_uuid,
+                "pending_results_len": len(inference_request["pending_results"]),
+                "frame_range": frame_range,
+            },
+        )
+        with inference_request["lock"]:
+            inference_request_copy = inference_request.copy()
+
+            if frame_range is not None:
+
+                def _in_range(figure):
+                    return (
+                        figure.frame_index >= frame_range[0]
+                        and figure.frame_index <= frame_range[1]
+                    )
+
+                inference_request_copy["pending_results"] = list(
+                    filter(_in_range, inference_request_copy["pending_results"])
+                )
+                inference_request["pending_results"] = list(
+                    filter(lambda x: not _in_range(x), inference_request["pending_results"])
+                )
+            else:
+                inference_request["pending_results"] = []
+        inference_request_copy.pop("lock")
+        inference_request_copy["progress"] = _convert_sly_progress_to_dict(
+            inference_request_copy["progress"]
+        )
+
+        inference_request_copy["pending_results"] = [
+            figure.to_json() for figure in inference_request_copy["pending_results"]
+        ]
+
+        return inference_request_copy
+
+    def _clear_tracking_results(self, inference_request_uuid):
+        del self._inference_requests[inference_request_uuid]
+        logger.debug("Removed an inference request:", extra={"uuid": inference_request_uuid})
+
+    def _stop_tracking(self, inference_request_uuid: str):
+        inference_request = self._inference_requests[inference_request_uuid]
+        inference_request["cancel_inference"] = True
+        logger.debug("Stopped tracking:", extra={"uuid": inference_request_uuid})
+
+    # Implement the following methods in the derived class
+    def track(self, api: Api, state: Dict, context: Dict):
+        raise NotImplementedError("Method `track` must be implemented.")
+
+    def track_api(self, api: Api, state: Dict, context: Dict):
+        raise NotImplementedError("Method `_track_api` must be implemented.")
+
+    def track_api_files(
+        self,
+        files: List[BinaryIO],
+        settings: Dict,
+    ):
+        raise NotImplementedError("Method `track_api_files` must be implemented.")
+
+    def track_async(self, api: Api, state: Dict, context: Dict):
+        raise NotImplementedError("Method `track_async` must be implemented.")
+
+    def stop_tracking(self, state: Dict, context: Dict):
+        validate_key(context, "inference_request_uuid", str)
+        inference_request_uuid = context["inference_request_uuid"]
+        self._stop_tracking(inference_request_uuid)
+        return {"message": "Inference will be stopped.", "success": True}
+
+    def pop_tracking_results(self, state: Dict, context: Dict):
+        validate_key(context, "inference_request_uuid", str)
+        inference_request_uuid = context["inference_request_uuid"]
+        frame_range = find_value_by_keys(context, ["frameRange", "frame_range", "frames"])
+        tracking_results = self._pop_tracking_results(inference_request_uuid, frame_range)
+        log_extra = _get_log_extra_for_inference_request(inference_request_uuid, tracking_results)
+        logger.debug(f"Sending inference delta results with uuid:", extra=log_extra)
+        return tracking_results
+
+    def clear_tracking_results(self, state: Dict, context: Dict):
+        self._clear_tracking_results(context)
+        return {"message": "Inference results cleared.", "success": True}
+
+    def _register_endpoints(self):
+        server = self._app.get_server()
+
+        @server.post("/track")
+        @handle_validation
+        def track_handler(request: Request):
+            api = request.state.api
+            state = request.state.state
+            context = request.state.context
+            logger.info("Received track request.", extra={"context": context, "state": state})
+            return self.track(api, state, context)
+
+        @server.post("/track-api")
+        @handle_validation
+        async def track_api_handler(request: Request):
+            api = request.state.api
+            state = request.state.state
+            context = request.state.context
+            logger.info("Received track-api request.", extra={"context": context, "state": state})
+            result = self.track_api(api, state, context)
+            logger.info("Track-api request processed.")
+            return result
+
+        @server.post("/track-api-files")
+        @handle_validation
+        def track_api_files(
+            files: List[UploadFile],
+            settings: str = Form("{}"),
+        ):
+            files = [file.file for file in files]
+            settings = json.loads(settings)
+            return self.track_api_files(files, settings)
+
+        @server.post("/track_async")
+        @handle_validation
+        def track_async_handler(request: Request):
+            api = request.state.api
+            state = request.state.state
+            context = request.state.context
+            logger.info("Received track_async request.", extra={"context": context, "state": state})
+            return self.track_async(api, state, context)
+
+        @server.post("/stop_tracking")
+        @handle_validation
+        def stop_tracking_handler(response: Response, request: Request):
+            state = request.state.state
+            context = request.state.context
+            logger.info(
+                "Received stop_tracking request.", extra={"context": context, "state": state}
+            )
+            return self.stop_tracking(state, context)
+
+        @server.post("/pop_tracking_results")
+        @handle_validation
+        def pop_tracking_results_handler(request: Request, response: Response):
+            state = request.state.state
+            context = request.state.context
+            logger.info(
+                "Received pop_tracking_results request.", extra={"context": context, "state": state}
+            )
+            return self.pop_tracking_results(state, context)
+
+        @server.post("/clear_tracking_results")
+        @handle_validation
+        def clear_tracking_results_handler(request: Request, response: Response):
+            context = request.state.context
+            state = request.state.state
+            logger.info(
+                "Received clear_tracking_results request.",
+                extra={"context": context, "state": state},
+            )
+            return self.clear_tracking_results(state, context)
+
+    def serve(self):
+        super().serve()
+        self._register_endpoints()