supervisely 6.73.261__py3-none-any.whl → 6.73.263__py3-none-any.whl

supervisely/__init__.py

@@ -309,4 +309,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.12"
+os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.17"

supervisely/api/app_api.py

@@ -1212,17 +1212,80 @@ class AppApi(TaskApi):
 
     def get_list(
         self,
-        team_id,
-        filter=None,
-        context=None,
-        repository_key=None,
-        show_disabled=False,
-        integrated_into=None,
-        session_tags=None,
-        only_running=False,
-        with_shared=True,
+        team_id: int,
+        filter: Optional[List[dict]] = None,
+        context: Optional[List[str]] = None,
+        repository_key: Optional[str] = None,
+        show_disabled: bool = False,
+        integrated_into: Optional[List[str]] = None,
+        session_tags: Optional[List[str]] = None,
+        only_running: bool = False,
+        with_shared: bool = True,
+        force_all_sessions: bool = True,
     ) -> List[AppInfo]:
-        """get_list"""
+        """
+        Get list of applications for the specified team.
+
+        :param team_id: team id
+        :type team_id: int
+        :param filter: list of filters
+        :type filter: Optional[List[dict]]
+        :param context: list of application contexts
+        :type context: Optional[List[str]]
+        :param repository_key: repository key
+        :type repository_key: Optional[str]
+        :param show_disabled: show disabled applications
+        :type show_disabled: bool
+        :param integrated_into: destination of the application.
+                    Available values: "panel", "files", "standalone", "data_commander",
+                                    "image_annotation_tool", "video_annotation_tool",
+                                    "dicom_annotation_tool", "pointcloud_annotation_tool"
+        :type integrated_into: Optional[List[str]]
+        :param session_tags: list of session tags
+        :type session_tags: Optional[List[str]]
+        :param only_running: show only running applications (status is one of "queued"/"consumed"/"started"/"deployed")
+        :type only_running: bool
+        :param with_shared: include shared applications
+        :type with_shared: bool
+        :param force_all_sessions: force to get all sessions (tasks) for each application.
+                                Works only if only_running is False.
+                                Note that it can be a long operation.
+        :type force_all_sessions: bool
+
+        :return: list of applications
+        :rtype: List[AppInfo]
+
+
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            team_id = 447
+
+            # Get list of all applications (including all tasks in `tasks` field)
+            apps = api.app.get_list(team_id=team_id)
+
+            # Get list of all applications (only running tasks included in `tasks` field)
+            apps = api.app.get_list(team_id=team_id, force_all_sessions=False)
+
+            # Get list of only running applications
+            apps = api.app.get_list(team_id=team_id, only_running=True)
+
+            # Get list of applications with specific filters
+            filter = [{"field": "moduleId", "operator": "=", "value": 428}]
+            apps = api.app.get_list(team_id=team_id, filter=filter)
+        """
+
+        if only_running is True:
+            # no need to get all sessions if only running sessions are requested
+            # (`force_all_sessions` has higher priority than only_running)
+            force_all_sessions = False
 
         return self.get_list_all_pages(
             method="apps.list",
@@ -1240,6 +1303,7 @@ class AppApi(TaskApi):
                 "onlyRunning": only_running,
                 "showDisabled": show_disabled,
                 "withShared": with_shared,
+                "forceAllSessions": force_all_sessions,
             },
         )
 
@@ -1479,49 +1543,105 @@ class AppApi(TaskApi):
 
     def get_sessions(
         self,
-        team_id,
-        module_id,
-        # only_running=False,
-        show_disabled=False,
-        session_name=None,
-        statuses: List[TaskApi.Status] = None,
+        team_id: int,
+        module_id: int,
+        show_disabled: bool = False,
+        session_name: Optional[str] = None,
+        statuses: Optional[List[TaskApi.Status]] = None,
+        with_shared: bool = False,
     ) -> List[SessionInfo]:
-        infos_json = self.get_list_all_pages(
-            method="apps.list",
-            data={
-                "teamId": team_id,
-                "filter": [{"field": "moduleId", "operator": "=", "value": module_id}],
-                # "onlyRunning": only_running,
-                "showDisabled": show_disabled,
-            },
-            convert_json_info_cb=lambda x: x,
-            # validate_total=False,
+        """
+        Get list of sessions (tasks) for the specified team and module.
+
+        :param team_id: team id
+        :type team_id: int
+        :param module_id: application module id
+        :type module_id: int
+        :param show_disabled: show disabled applications
+        :type show_disabled: bool
+        :param session_name: session name to filter sessions
+        :type session_name: Optional[str]
+        :param statuses: list of statuses to filter sessions
+        :type statuses: Optional[List[TaskApi.Status]]
+        :param with_shared: include shared application sessions
+        :type with_shared: bool
+
+        :return: list of sessions
+        :rtype: List[SessionInfo]
+
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            team_id = 447
+            module_id = 428
+
+            # Get list of all sessions for the specified team and module ID
+            sessions = api.app.get_sessions(team_id, module_id)
+
+            # Get list of sessions with specific statuses
+            from supervisely.api.task_api import TaskApi
+
+            statuses = [TaskApi.Status.STARTED]
+            sessions = api.app.get_sessions(team_id, module_id, statuses=statuses)
+        """
+
+        infos_json = self.get_list(
+            team_id,
+            filter=[
+                {
+                    ApiField.FIELD: ApiField.MODULE_ID,
+                    ApiField.OPERATOR: "=",
+                    ApiField.VALUE: module_id,
+                }
+            ],
+            with_shared=with_shared,
+            only_running=False,
+            force_all_sessions=False,
         )
-        if len(infos_json) == 0:
-            # raise KeyError(f"App [module_id = {module_id}] not found in team {team_id}")
-            return []
-        if len(infos_json) > 1:
+        if len(infos_json) > 1 and with_shared is False:
             raise KeyError(
                 f"Apps list in team is broken: app [module_id = {module_id}] added to team {team_id} multiple times"
             )
-        dev_tasks = []
-        sessions = infos_json[0]["tasks"]
-
-        str_statuses = []
-        if statuses is not None:
-            for s in statuses:
-                str_statuses.append(str(s))
-
+        sessions = []
+        for app in infos_json:
+            data = {
+                ApiField.TEAM_ID: team_id,
+                ApiField.APP_ID: app.id,
+                # ApiField.ONLY_RUNNING: False,
+                ApiField.SHOW_DISABLED: show_disabled,
+                ApiField.WITH_SHARED: with_shared,
+                ApiField.SORT: ApiField.STARTED_AT,
+                ApiField.SORT_ORDER: "desc",
+            }
+            if statuses is not None:
+                data[ApiField.FILTER] = [
+                    {
+                        ApiField.FIELD: ApiField.STATUS,
+                        ApiField.OPERATOR: "in",
+                        ApiField.VALUE: [str(s) for s in statuses],
+                    }
+                ]
+            sessions.extend(
+                self.get_list_all_pages(
+                    method="apps.tasks.list",
+                    data=data,
+                    convert_json_info_cb=lambda x: x,
+                )
+            )
+        session_infos = []
         for session in sessions:
-            to_add = True
             if session_name is not None and session["meta"]["name"] != session_name:
-                to_add = False
-            if statuses is not None and session["status"] not in str_statuses:
-                to_add = False
-            if to_add is True:
-                session["moduleId"] = module_id
-                dev_tasks.append(SessionInfo.from_json(session))
-        return dev_tasks
+                continue
+            session["moduleId"] = module_id
+            session_infos.append(SessionInfo.from_json(session))
+        return session_infos
 
     def start(
         self,

supervisely/api/module_api.py

@@ -596,6 +596,12 @@ class ApiField:
     """"""
     CLEAR_LOCAL_DATA_SOURCE = "clearLocalDataSource"
     """"""
+    ONLY_RUNNING = "onlyRunning"
+    """"""
+    SHOW_DISABLED = "showDisabled"
+    """"""
+    WITH_SHARED = "withShared"
+    """"""
 
 
 def _get_single_item(items):

supervisely/nn/inference/cache.py

@@ -1,11 +1,11 @@
 import json
 import shutil
+import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from enum import Enum
 from logging import Logger
 from pathlib import Path
 from threading import Lock, Thread
-from time import sleep
 from typing import Any, Callable, Generator, List, Optional, Tuple, Union
 
 import cv2
@@ -140,7 +140,7 @@ class PersistentImageTTLCache(TTLCache):
         self[video_id] = video_path
         if src_video_path != str(video_path):
             shutil.move(src_video_path, str(video_path))
-        sly.logger.debug(f"Saved video to {video_path}")
+        sly.logger.debug(f"Video #{video_id} saved to {video_path}", extra={"video_id": video_id})
 
     def get_video_path(self, video_id: int) -> Path:
         return self[video_id]
@@ -197,12 +197,14 @@ class InferenceImageCache:
         ttl: int,
         is_persistent: bool = True,
         base_folder: str = sly.env.smart_cache_container_dir(),
+        log_progress: bool = False,
     ) -> None:
         self.is_persistent = is_persistent
         self._maxsize = maxsize
         self._ttl = ttl
         self._lock = Lock()
-        self._load_queue = CacheOut(10 * 60)
+        self._load_queue = CacheOut(ttl=10 * 60)
+        self.log_progress = log_progress
 
         if is_persistent:
             self._data_dir = Path(base_folder)
@@ -342,11 +344,13 @@ class InferenceImageCache:
                 Thread(
                     target=self.download_video,
                     args=(api, video_id),
-                    kwargs={"return_images": False},
+                    kwargs={**kwargs, "return_images": False},
                 ).start()
         elif redownload_video:
             Thread(
-                target=self.download_video, args=(api, video_id), kwargs={"return_images": False}
+                target=self.download_video,
+                args=(api, video_id),
+                kwargs={**kwargs, "return_images": False},
             ).start()
 
         def name_constuctor(frame_index: int):
@@ -371,6 +375,7 @@ class InferenceImageCache:
             with self._lock:
                 self._cache.save_video(video_id, str(video_path))
                 self._load_queue.delete(video_id)
+            sly.logger.debug(f"Video #{video_id} added to cache", extra={"video_id": video_id})
         else:
             cap = cv2.VideoCapture(str(video_path))
             frame_index = 0
@@ -396,17 +401,57 @@ 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 = api.video.get_info_by_id(video_id)
         self._wait_if_in_queue(video_id, api.logger)
         if not video_id in self._cache:
+            download_time = time.monotonic()
             self._load_queue.set(video_id, video_id)
-            sly.logger.debug("Downloading video #%s", video_id)
-            temp_video_path = Path("/tmp/smart_cache").joinpath(
-                f"_{sly.rand_str(6)}_" + video_info.name
-            )
-            api.video.download_path(video_id, temp_video_path, progress_cb=progress_cb)
-            self.add_video_to_cache(video_id, temp_video_path)
+            try:
+                sly.logger.debug("Downloading video #%s", video_id)
+                if progress_cb is None and self.log_progress:
+                    size = video_info.file_meta.get("size", None)
+                    if size is None:
+                        size = "unknown"
+                    else:
+                        size = int(size)
+
+                    prog_n = 0
+                    prog_t = time.monotonic()
+
+                    def _progress_cb(n):
+                        nonlocal prog_n
+                        nonlocal prog_t
+                        prog_n += n
+                        cur_t = time.monotonic()
+                        if cur_t - prog_t > 3 or (isinstance(size, int) and prog_n >= size):
+                            prog_t = cur_t
+                            percent_str = ""
+                            if isinstance(size, int):
+                                percent_str = f" ({(prog_n*100) // size}%)"
+                            prog_str = (
+                                f"{(prog_n / 1000000):.2f}/{(size / 1000000):.2f} MB{percent_str}"
+                            )
+                            sly.logger.debug(
+                                "Downloading video #%s: %s",
+                                video_id,
+                                prog_str,
+                            )
+
+                    progress_cb = _progress_cb
+                temp_video_path = Path("/tmp/smart_cache").joinpath(
+                    f"_{sly.rand_str(6)}_" + video_info.name
+                )
+                api.video.download_path(video_id, temp_video_path, progress_cb=progress_cb)
+                self.add_video_to_cache(video_id, temp_video_path)
+                download_time = time.monotonic() - download_time
+                api.logger.debug(
+                    f"Video #{video_id} downloaded to cache in {download_time:.2f} sec",
+                    extra={"video_id": video_id, "download_time": download_time},
+                )
+            except Exception as e:
+                self._load_queue.delete(video_id)
+                raise e
         if return_images:
             return self.get_frames_from_cache(video_id, list(range(video_info.frames_count)))
 
@@ -664,6 +709,7 @@ class InferenceImageCache:
                 for pos, image in executor.map(get_one_image, items):
                     all_frames[pos] = image
 
+        download_time = time.monotonic()
         if len(indexes_to_load) > 0:
             for id_or_hash, image in load_generator(indexes_to_load):
                 name = name_cunstructor(id_or_hash)
@@ -672,9 +718,13 @@ class InferenceImageCache:
                 if return_images:
                     pos = pos_by_name[name]
                     all_frames[pos] = image
+        download_time = time.monotonic() - download_time
 
         # logger.debug(f"All stored files: {sorted(os.listdir(self.tmp_path))}")
-        logger.debug(f"Images/Frames added to cache: {indexes_to_load}")
+        logger.debug(
+            f"Images/Frames added to cache: {indexes_to_load} in {download_time:.2f} sec",
+            extra={"indexes": indexes_to_load, "download_time": download_time},
+        )
         logger.debug(f"Images/Frames found in cache: {set(indexes).difference(indexes_to_load)}")
 
         if return_images:
@@ -686,8 +736,8 @@ class InferenceImageCache:
             logger.debug(f"Waiting for other task to load {name}")
 
         while name in self._load_queue:
-            # TODO: sleep if slowdown
-            sleep(0.1)
+            # TODO: time.sleep if slowdown
+            time.sleep(0.1)
             continue
 
     def download_frames_to_paths(self, api, video_id, frame_indexes, paths, progress_cb=None):

supervisely/nn/inference/inference.py

@@ -228,6 +228,7 @@ class Inference:
             ttl=env.smart_cache_ttl(),
             is_persistent=True,
             base_folder=env.smart_cache_container_dir(),
+            log_progress=True,
         )
 
     def get_batch_size(self):

supervisely/nn/inference/tracking/bbox_tracking.py

@@ -1,6 +1,7 @@
 import functools
 import json
 import time
+import uuid
 from pathlib import Path
 from queue import Queue
 from threading import Event, Thread
@@ -154,7 +155,8 @@ class BBoxTracking(Inference):
             raise
         stop_upload_event.set()
 
-    def _track_api(self, api: sly.Api, context: dict):
+    def _track_api(self, api: sly.Api, context: dict, request_uuid: str = None):
+        track_t = time.monotonic()
         # unused fields:
         context["trackId"] = "auto"
         context["objectIds"] = []
@@ -193,15 +195,27 @@ class BBoxTracking(Inference):
                 video_id=video_interface.video_id,
             )
 
-        api.logger.info("Start tracking.")
-
         predictions = []
-        for input_geom in input_bboxes:
+        frames_n = video_interface.frames_count
+        box_n = len(input_bboxes)
+        geom_t = time.monotonic()
+        api.logger.info(
+            "Start tracking.",
+            extra={
+                "video_id": video_interface.video_id,
+                "frame_range": range_of_frames,
+                "geometries_count": box_n,
+                "frames_count": frames_n,
+                "request_uuid": request_uuid,
+            },
+        )
+        for box_i, input_geom in enumerate(input_bboxes, 1):
             input_bbox = input_geom["data"]
             bbox = sly.Rectangle.from_json(input_bbox)
             predictions_for_object = []
             init = False
-            for _ in video_interface.frames_loader_generator():
+            frame_t = time.monotonic()
+            for frame_i, _ in enumerate(video_interface.frames_loader_generator(), 1):
                 imgs = video_interface.frames
                 target = PredictionBBox(
                     "",  # TODO: can this be useful?
@@ -224,10 +238,40 @@ class BBoxTracking(Inference):
                 predictions_for_object.append(
                     {"type": sly_geometry.geometry_name(), "data": sly_geometry.to_json()}
                 )
+                api.logger.debug(
+                    "Frame processed. Geometry: [%d / %d]. Frame: [%d / %d]",
+                    box_i,
+                    box_n,
+                    frame_i,
+                    frames_n,
+                    extra={
+                        "geometry_index": box_i,
+                        "frame_index": frame_i,
+                        "processing_time": time.monotonic() - frame_t,
+                        "request_uuid": request_uuid,
+                    },
+                )
+                frame_t = time.monotonic()
+
             predictions.append(predictions_for_object)
+            api.logger.info(
+                "Geometry processed. Progress: [%d / %d]",
+                box_i,
+                box_n,
+                extra={
+                    "geometry_index": box_i,
+                    "processing_time": time.monotonic() - geom_t,
+                    "request_uuid": request_uuid,
+                },
+            )
+            geom_t = time.monotonic()
 
         # predictions must be NxK bboxes: N=number of frames, K=number of objects
         predictions = list(map(list, zip(*predictions)))
+        api.logger.info(
+            "Tracking finished.",
+            extra={"tracking_time": time.monotonic() - track_t, "request_uuid": request_uuid},
+        )
         return predictions
 
     def _inference(self, frames: List[np.ndarray], geometries: List[Geometry], settings: dict):
@@ -322,8 +366,19 @@ class BBoxTracking(Inference):
 
         @server.post("/track-api")
         def track_api(request: Request):
-            sly.logger.info("Start tracking.")
-            return self._track_api(request.state.api, request.state.context)
+            inference_request_uuid = uuid.uuid5(
+                namespace=uuid.NAMESPACE_URL, name=f"{time.time()}"
+            ).hex
+            sly.logger.info(
+                "Received track-api request.", extra={"request_uuid": inference_request_uuid}
+            )
+            result = self._track_api(
+                request.state.api, request.state.context, request_uuid=inference_request_uuid
+            )
+            sly.logger.info(
+                "Track-api request processed.", extra={"request_uuid": inference_request_uuid}
+            )
+            return result
 
         @server.post("/track-api-files")
         def track_api_files(

supervisely/nn/inference/tracking/tracker_interface.py

@@ -73,7 +73,7 @@ class TrackerInterface:
 
         self.geometries[start_fig] = geometries[-1]
 
-    def frames_loader_generator(self, batch_size=16) -> Generator[None, None, None]:
+    def frames_loader_generator(self, batch_size=4) -> Generator[None, None, None]:
         if self.load_all_frames:
             self._cur_frames_indexes = self.frames_indexes
             yield

{supervisely-6.73.261.dist-info → supervisely-6.73.263.dist-info}/METADATA

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

{supervisely-6.73.261.dist-info → supervisely-6.73.263.dist-info}/RECORD

@@ -1,5 +1,5 @@
 supervisely/README.md,sha256=XM-DiMC6To3I9RjQZ0c61905EFRR_jnCUx2q3uNR-X8,3331
-supervisely/__init__.py,sha256=AV335r212Ln_vTroiucb5T6yFuAlMKxKzldjMbW3gA8,10800
+supervisely/__init__.py,sha256=x83gx4W-dVuR8-6vthw5nZptfR0k_1FLQfXs7H36c3Q,10800
 supervisely/_utils.py,sha256=I4nZ0L7NS6144r-CQ2VJvLeUJZ1bCi4pYXH4Gxo3-D4,15763
 supervisely/function_wrapper.py,sha256=R5YajTQ0GnRp2vtjwfC9hINkzQc0JiyGsu8TER373xY,1912
 supervisely/sly_logger.py,sha256=LG1wTyyctyEKuCuKM2IKf_SMPH7BzkTsFdO-0tnorzg,6225
@@ -23,7 +23,7 @@ supervisely/api/advanced_api.py,sha256=Nd5cCnHFWc3PSUrCtENxTGtDjS37_lCHXsgXvUI3T
 supervisely/api/agent_api.py,sha256=ShWAIlXcWXcyI9fqVuP5GZVCigCMJmjnvdGUfLspD6Y,8890
 supervisely/api/annotation_api.py,sha256=kB9l0NhQEkunGDC9fWjNzf5DdhqRF1tv-RRnIbkV2k0,64941
 supervisely/api/api.py,sha256=0dgPx_eizoCEFzfT8YH9uh1kq-OJwjrV5fBGD7uZ7E4,65840
-supervisely/api/app_api.py,sha256=-T4sISQ7POyR2yirf1kEWj4JaJFpJxCyRWqbf_99Jak,67036
+supervisely/api/app_api.py,sha256=RsbVej8WxWVn9cNo5s3Fqd1symsCdsfOaKVBKEUapRY,71927
 supervisely/api/dataset_api.py,sha256=eovT6l62jgjlRyCZ6IvoudUBfDxv9Hjj3Ap8IuCLd7I,41290
 supervisely/api/file_api.py,sha256=7yWt8lRQ4UfLmnMZ9T18UXzu8jihrtHtcqi6GZJG-0w,83414
 supervisely/api/github_api.py,sha256=NIexNjEer9H5rf5sw2LEZd7C1WR-tK4t6IZzsgeAAwQ,623
@@ -32,7 +32,7 @@ supervisely/api/image_api.py,sha256=2cki-IzA5jnN3QqqdSIbIbHJhDWxFGYxXY94WqBOoio,
 supervisely/api/import_storage_api.py,sha256=BDCgmR0Hv6OoiRHLCVPKt3iDxSVlQp1WrnKhAK_Zl84,460
 supervisely/api/issues_api.py,sha256=BqDJXmNoTzwc3xe6_-mA7FDFC5QQ-ahGbXk_HmpkSeQ,17925
 supervisely/api/labeling_job_api.py,sha256=odnzZjp29yM16Gq-FYkv-OA4WFMNJCLFo4qSikW2A7c,56280
-supervisely/api/module_api.py,sha256=ajVPU5bH1sB-l2PwWq_xtFxSmZIBikflousOxiAYmW4,43141
+supervisely/api/module_api.py,sha256=8z7K6K77fa9oijnix4vnCADJwe5nZtsDiWKZTWc_yuI,43273
 supervisely/api/neural_network_api.py,sha256=ktPVRO4Jeulougio8F0mioJJHwRJcX250Djp1wBoQ9c,7620
 supervisely/api/object_class_api.py,sha256=-rQcKwhBw3iL9KNH9c1ROgoimgWM1ls6Wi_tb1R-MzY,7683
 supervisely/api/plugin_api.py,sha256=TlfrosdRuYG4NUxk92QiQoVaOdztFspPpygyVa3M3zk,5283
@@ -858,8 +858,8 @@ supervisely/nn/benchmark/visualization/widgets/sidebar/sidebar.py,sha256=tKPURRS
 supervisely/nn/benchmark/visualization/widgets/table/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/nn/benchmark/visualization/widgets/table/table.py,sha256=atmDnF1Af6qLQBUjLhK18RMDKAYlxnsuVHMSEa5a-e8,4319
 supervisely/nn/inference/__init__.py,sha256=mtEci4Puu-fRXDnGn8RP47o97rv3VTE0hjbYO34Zwqg,1622
-supervisely/nn/inference/cache.py,sha256=KvzCgMbEBLdiJAxJDLicIPKAlYb52P9_kpNPWfiVY8Y,28194
-supervisely/nn/inference/inference.py,sha256=acNJH-1UthvJgyhI-9KJv8hzo8LjOVVdXPkoEuwfRLg,128864
+supervisely/nn/inference/cache.py,sha256=_pPSpkl8Wkqkiidn0vu6kWE19cngd80av--jncHxMEQ,30510
+supervisely/nn/inference/inference.py,sha256=8MrOen2oyYIKiVqy0WbBTwABJZss9MLQ70EwX0e_-es,128895
 supervisely/nn/inference/session.py,sha256=jmkkxbe2kH-lEgUU6Afh62jP68dxfhF5v6OGDfLU62E,35757
 supervisely/nn/inference/video_inference.py,sha256=8Bshjr6rDyLay5Za8IB8Dr6FURMO2R_v7aELasO8pR4,5746
 supervisely/nn/inference/gui/__init__.py,sha256=wCxd-lF5Zhcwsis-wScDA8n1Gk_1O00PKgDviUZ3F1U,221
@@ -892,13 +892,13 @@ supervisely/nn/inference/salient_object_segmentation/salient_object_segmentation
 supervisely/nn/inference/semantic_segmentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/nn/inference/semantic_segmentation/semantic_segmentation.py,sha256=xpmViSYm1v_ZxlYyqiD_DiB7_LEynv9ZoU0t2QHEx8A,3370
 supervisely/nn/inference/tracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-supervisely/nn/inference/tracking/bbox_tracking.py,sha256=URWGoYrCRN3yC4MyLx2_eZziZYwX6mPA8OLJqUOsAgA,15307
+supervisely/nn/inference/tracking/bbox_tracking.py,sha256=EBEwLczXugCSYaIUFxB33h7SOIkPDEBWLhr_TbASNOA,17441
 supervisely/nn/inference/tracking/functional.py,sha256=LpVu2gvOOpr9D_uvwTPZey1wUCAhV-E20RPKmCSIrK4,1774
 supervisely/nn/inference/tracking/mask_tracking.py,sha256=qL9eUSqhzJwJMYaAzXX31oOu9EgdnGbsNwK9pOlV148,19610
 supervisely/nn/inference/tracking/object_tracking_3d.py,sha256=Kqvx1qe1G8F1VtdBiy2HJ251rJU6s3LWhj0ZedhrmUw,4327
 supervisely/nn/inference/tracking/point_tracking.py,sha256=Dweiq3dJUuwlFYnJbyx28L3IisNeg-1KQf2mBHrr7yI,22050
 supervisely/nn/inference/tracking/tracker3d_interface.py,sha256=7yIkNO9rgkzQuyXUUccLwqlv5k7RPbxTqz9uI4FylLE,2781
-supervisely/nn/inference/tracking/tracker_interface.py,sha256=MJFzSpQvhC0F-HoryRuoDinO_5xS5oFvT5zDE94ZyKY,10767
+supervisely/nn/inference/tracking/tracker_interface.py,sha256=FXI9f0I5Tb5HN7l8fvxJ5wJ-QYuKyxfXiDpfXRLsSq4,10766
 supervisely/nn/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/nn/legacy/config.py,sha256=TKdyGtURJKzKoyydCZAfujoUnbC0SO8GeVLTSnoyS_w,2994
 supervisely/nn/legacy/dataset.py,sha256=-56EI6OYbkTWx4y8hOgD76y47zUoJNjGFyZ6JaP8iqg,6055
@@ -1057,9 +1057,9 @@ supervisely/worker_proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 supervisely/worker_proto/worker_api_pb2.py,sha256=VQfi5JRBHs2pFCK1snec3JECgGnua3Xjqw_-b3aFxuM,59142
 supervisely/worker_proto/worker_api_pb2_grpc.py,sha256=3BwQXOaP9qpdi0Dt9EKG--Lm8KGN0C5AgmUfRv77_Jk,28940
 supervisely_lib/__init__.py,sha256=7-3QnN8Zf0wj8NCr2oJmqoQWMKKPKTECvjH9pd2S5vY,159
-supervisely-6.73.261.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.261.dist-info/METADATA,sha256=-ebDT49QDbB4Ly0fCqehbeu-_SN7bLV1lObohSxHS4M,33573
-supervisely-6.73.261.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-supervisely-6.73.261.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.261.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.261.dist-info/RECORD,,
+supervisely-6.73.263.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.263.dist-info/METADATA,sha256=M3YKXXtM4dpAgiB1GET6JjPaejX6M-qq4mmSAu4wis8,33573
+supervisely-6.73.263.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+supervisely-6.73.263.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.263.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.263.dist-info/RECORD,,