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

supervisely/nn/inference/tracking/tracker_interface.py

@@ -1,15 +1,26 @@
+import time
 import uuid
-from collections import OrderedDict
+from collections import OrderedDict, namedtuple
 from logging import Logger
-from typing import Callable, Dict, Generator, List, Optional
+from queue import Queue
+from threading import Lock, Thread
+from typing import Any, Callable, Dict, Generator, List, Optional
 from typing import OrderedDict as OrderedDictType
 
 import numpy as np
 
-import supervisely as sly
+from supervisely._utils import find_value_by_keys
+from supervisely.api.api import Api
 from supervisely.api.module_api import ApiField
 from supervisely.geometry.geometry import Geometry
-from supervisely.video_annotation.video_figure import VideoFigure
+from supervisely.geometry.graph import GraphNodes
+from supervisely.geometry.helpers import deserialize_geometry
+from supervisely.geometry.point import Point
+from supervisely.geometry.polygon import Polygon
+from supervisely.geometry.polyline import Polyline
+from supervisely.nn.inference.cache import InferenceImageCache
+from supervisely.sly_logger import logger
+from supervisely.video_annotation.key_id_map import KeyIdMap
 
 
 class TrackerInterface:
@@ -20,11 +31,11 @@ class TrackerInterface:
         load_all_frames=False,
         notify_in_predict=False,
         per_point_polygon_tracking=True,
-        frame_loader: Callable[[sly.Api, int, int], np.ndarray] = None,
-        frames_loader: Callable[[sly.Api, int, List[int]], List[np.ndarray]] = None,
+        frame_loader: Callable[[Api, int, int], np.ndarray] = None,
+        frames_loader: Callable[[Api, int, List[int]], List[np.ndarray]] = None,
         should_notify: bool = True,
     ):
-        self.api: sly.Api = api
+        self.api: Api = api
         self.logger: Logger = api.logger
         self.frame_index = context["frameIndex"]
         self.frames_count = context["frames"]
@@ -131,7 +142,7 @@ class TrackerInterface:
                 for geometry, frame_index in geometries_frame_indexes
             ]
             figures_keys = [uuid.uuid4() for _ in figures_json]
-            key_id_map = sly.KeyIdMap()
+            key_id_map = KeyIdMap()
             self.api.video.figure._append_bulk(
                 entity_id=self.video_id,
                 figures_json=figures_json,
@@ -169,19 +180,19 @@ class TrackerInterface:
         points = 0
         for figure_id in self.figure_ids:
             figure = self.api.video.figure.get_info_by_id(figure_id)
-            geometry = sly.deserialize_geometry(figure.geometry_type, figure.geometry)
+            geometry = deserialize_geometry(figure.geometry_type, figure.geometry)
             self.geometries[figure_id] = geometry
 
             self.api.logger.debug(f"Added {figure.geometry_type} #{figure_id}")
 
             # per point track notification
-            if isinstance(geometry, sly.Point):
+            if isinstance(geometry, Point):
                 points += 1
-            elif isinstance(geometry, sly.Polygon):
+            elif isinstance(geometry, Polygon):
                 points += len(geometry.exterior) + len(geometry.interior)
-            elif isinstance(geometry, sly.GraphNodes):
+            elif isinstance(geometry, GraphNodes):
                 points += len(geometry.nodes.items())
-            elif isinstance(geometry, sly.Polyline):
+            elif isinstance(geometry, Polyline):
                 points += len(geometry.exterior)
 
         if self.per_point_polygon_tracking:
@@ -289,3 +300,325 @@ class TrackerInterface:
         """Use this in prediction."""
         self._notify(task="get frames")
         return self._frames
+
+
+class ThreadSafeStopIndicator:
+    def __init__(self):
+        self._stopped = False
+        self._reason = None
+        self._lock = Lock()
+
+    def stop(self, reason: Any = None):
+        if self.is_stopped():
+            return
+        with self._lock:
+            self._stopped = True
+            self._reason = reason
+
+    def is_stopped(self):
+        with self._lock:
+            return self._stopped
+
+    def get_reason(self):
+        with self._lock:
+            return self._reason
+
+
+FrameImage = namedtuple("FrameImage", ["frame_index", "image"])
+
+
+class TrackerInterfaceV2:
+    UPLOAD_SLEEP_TIME = 0.001  # 1ms
+    NOTIFY_SLEEP_TIME = 1  # 1s
+
+    def __init__(
+        self,
+        api: Api,
+        context: Dict,
+        cache: InferenceImageCache,
+    ):
+        self.api = api
+        self.context = context
+        self.video_id = find_value_by_keys(context, ["videoId", "video_id"])
+        self.frame_index = find_value_by_keys(context, ["frameIndex", "frame_index"])
+        self.frames_count = find_value_by_keys(context, ["frames", "framesCount", "frames_count"])
+        self.track_id = context.get("trackId", "auto")
+        self.direction = context.get("direction", "forward")
+        self.session_id = find_value_by_keys(context, ["sessionId", "session_id"], None)
+        self.figures = context.get("figures", None)
+        self.direct_progress = context.get("useDirectProgressMessages", False)
+        self.direction_n = 1 if self.direction == "forward" else -1
+        self.stop_indicator = ThreadSafeStopIndicator()
+        self.cache = cache
+        self.frame_indexes = list(
+            range(
+                self.frame_index,
+                self.frame_index + self.frames_count * self.direction_n + self.direction_n,
+                self.direction_n,
+            )
+        )
+
+        self.log_extra = {
+            "video_id": self.video_id,
+            "track_id": self.track_id,
+            "session_id": self.session_id,
+        }
+
+        # start caching task
+        self.run_cache_frames_task()
+
+        self.upload_sleep_time = self.UPLOAD_SLEEP_TIME
+        self.notify_sleep_time = self.NOTIFY_SLEEP_TIME
+        self.upload_queue = Queue()
+        self.notify_queue = Queue()
+        self.upload_thread = None
+        self.notify_thread = None
+        self._upload_f = None
+        self._notify_f = None
+
+    def __call__(self, upload_f, notify_f):
+        self.upload_f = upload_f
+        self.notify_f = notify_f
+        return self
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.wait_stop(exception=exc_value)
+        return False
+
+    @property
+    def upload_f(self):
+        return self._upload_f
+
+    @upload_f.setter
+    def upload_f(self, upload_f):
+        self._upload_f = upload_f
+        self.upload_thread = Thread(
+            target=self._upload_loop,
+            args=[
+                self.upload_queue,
+                self.notify_queue,
+                self.stop_indicator,
+                self._upload_f,
+                self.upload_sleep_time,
+                self._upload_exception_handler,
+            ],
+            daemon=True,
+        )
+
+    @property
+    def notify_f(self):
+        return self._notify_f
+
+    @notify_f.setter
+    def notify_f(self, notify_f):
+        self._notify_f = notify_f
+        self.notify_thread = Thread(
+            target=self._nofify_loop,
+            args=[
+                self.notify_queue,
+                self.stop_indicator,
+                self._notify_f,
+                self.notify_sleep_time,
+                self._notify_exception_handler,
+            ],
+            daemon=True,
+        )
+
+    def start(self):
+        if self.upload_thread is not None:
+            self.upload_thread.start()
+        if self.notify_thread is not None:
+            self.notify_thread.start()
+
+    def stop(self, exception: Exception = None):
+        self.stop_indicator.stop(exception)
+
+    def join(self, timeout: Optional[float] = 5 * 60):
+        if self.upload_thread is not None and self.upload_thread.is_alive():
+            self.upload_thread.join(timeout=timeout)
+        if self.notify_thread is not None and self.notify_thread.is_alive():
+            self.notify_thread.join(timeout=timeout)
+
+    def wait_stop(self, exception: Exception = None, timeout: Optional[float] = 5 * 60):
+        self.stop(exception)
+        self.join(timeout=timeout)
+
+    def is_stopped(self):
+        return self.stop_indicator.is_stopped()
+
+    def stop_reason(self):
+        return self.stop_indicator.get_reason()
+
+    @classmethod
+    def _upload_loop(
+        cls,
+        q: Queue,
+        notify_q: Queue,
+        stop_indicator: ThreadSafeStopIndicator,
+        upload_f: callable = None,
+        upload_sleep_time: float = None,
+        exception_handler: callable = None,
+    ):
+        logger.debug("Upload loop started")
+        if upload_f is None:
+            logger.warning("Upload function is not provided. Exiting upload loop.")
+            return
+        upload_sleep_time = upload_sleep_time or cls.UPLOAD_SLEEP_TIME
+        try:
+            while True:
+                items = []
+                while not q.empty():
+                    items.append(q.get_nowait())
+                if len(items) > 0:
+                    upload_f(items)
+                    for item in items:
+                        notify_q.put(item)
+                elif stop_indicator.is_stopped():
+                    logger.debug("stop event is set. returning from upload loop")
+                    return
+                time.sleep(upload_sleep_time)
+        except Exception as e:
+            if exception_handler is not None:
+                e = exception_handler(e)
+                if not isinstance(e, Exception):
+                    return
+                raise e
+            logger.error("Error in upload loop: %s", str(e), exc_info=True)
+            raise
+
+    @classmethod
+    def _nofify_loop(
+        cls,
+        q: Queue,
+        stop_indicator: ThreadSafeStopIndicator,
+        notify_f: callable = None,
+        notify_sleep_time: float = None,
+        exception_handler: callable = None,
+    ):
+        logger.debug("Notify loop started")
+        if notify_f is None:
+            logger.warning("Notify function is not provided. Exiting notify loop.")
+            return
+        notify_sleep_time = notify_sleep_time or cls.NOTIFY_SLEEP_TIME
+        try:
+            while True:
+                items = []
+                while not q.empty():
+                    items.append(q.get_nowait())
+                if len(items) > 0:
+                    notify_f(items)
+                elif stop_indicator.is_stopped():
+                    logger.debug(f"stop event is set. returning from notify loop")
+                    return
+                time.sleep(notify_sleep_time)
+        except Exception as e:
+            if exception_handler is not None:
+                e = exception_handler(e)
+                if not isinstance(e, Exception):
+                    return
+                raise e
+            logger.error("Error in notify loop: %s", str(e), exc_info=True)
+            raise
+
+    def run_cache_frames_task(self):
+        if self.cache.is_persistent:
+            frame_ranges = None
+        else:
+            frame_ranges = [
+                self.frame_index,
+                self.frame_index + self.frames_count * self.direction_n,
+            ]
+            if self.direction_n == -1:
+                frame_ranges = frame_ranges[::-1]
+            frame_ranges = [frame_ranges]
+        self.cache.run_cache_task_manually(
+            self.api,
+            frame_ranges,
+            video_id=self.video_id,
+        )
+
+    def frames_loader_generator(
+        self, batch_size=2, step=1
+    ) -> Generator[List[FrameImage], None, None]:
+        step = step * self.direction_n
+        batch = []
+        t = time.monotonic()
+        for frame_i, frame in zip(
+            self.frame_indexes,
+            self.cache.frames_loader(
+                self.api, video_id=self.video_id, frame_indexes=self.frame_indexes
+            ),
+        ):
+            batch.append(FrameImage(frame_i, frame))
+            if len(batch) == batch_size:
+                _get_indexes_str = lambda b: ", ".join(map(lambda x: str(x.frame_index), b))
+                if len(batch) > 16:
+                    batch_indexes_str = (
+                        _get_indexes_str(batch[:8]) + " ... " + _get_indexes_str(batch[-8:])
+                    )
+                else:
+                    batch_indexes_str = _get_indexes_str(batch)
+
+                logger.debug(
+                    f"Frames [{batch_indexes_str}] loaded. Time: {time.monotonic() - t}",
+                    extra=self.log_extra,
+                )
+                yield batch
+                t = time.monotonic()
+                batch = batch[step:]
+
+    def load_all_frames(self):
+        return next(self.frames_loader_generator(batch_size=len(self.frame_indexes)))
+
+    def add_prediction(self, item: Any):
+        self.upload_queue.put(item)
+
+    def notify_progress(
+        self,
+        progress_current: int,
+        progress_total: int,
+        frame_range: List[int] = None,
+    ):
+        logger.debug(
+            f"Notify progress: {progress_current}/{progress_total} on frames {frame_range}",
+            extra=self.log_extra,
+        )
+        if self.direct_progress:
+            self.api.vid_ann_tool.set_direct_tracking_progress(
+                self.session_id,
+                self.video_id,
+                self.track_id,
+                frame_range=frame_range,
+                progress_current=progress_current,
+                progress_total=progress_total,
+            )
+        else:
+            stopped = self.api.video.notify_progress(
+                self.track_id,
+                self.video_id,
+                frame_range[0],
+                frame_range[1],
+                progress_current,
+                progress_total,
+            )
+            if stopped and progress_current < progress_total:
+                logger.info("Task stopped by user.", extra=self.log_extra)
+                self.stop()
+
+    def _upload_exception_handler(self, exception: Exception):
+        logger.error(
+            "Error in upload loop: %s", str(exception), exc_info=True, extra=self.log_extra
+        )
+        self.stop_indicator.stop(exception)
+        raise exception
+
+    def _notify_exception_handler(self, exception: Exception):
+        logger.error(
+            "Error in notify loop: %s", str(exception), exc_info=True, extra=self.log_extra
+        )
+        self.stop_indicator.stop(exception)
+        raise exception

{supervisely-6.73.284.dist-info → supervisely-6.73.286.dist-info}/METADATA

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

{supervisely-6.73.284.dist-info → supervisely-6.73.286.dist-info}/RECORD

@@ -1,6 +1,6 @@
 supervisely/README.md,sha256=XM-DiMC6To3I9RjQZ0c61905EFRR_jnCUx2q3uNR-X8,3331
-supervisely/__init__.py,sha256=bvuMHtPSeGkhj3vVvcVtyhVcMqI5OEBPflLcy8HIqN8,10833
-supervisely/_utils.py,sha256=I4nZ0L7NS6144r-CQ2VJvLeUJZ1bCi4pYXH4Gxo3-D4,15763
+supervisely/__init__.py,sha256=xrUgQsIthS0kN4wPKAWP38oNX1KGQSg6MtJux9joKbA,10833
+supervisely/_utils.py,sha256=DX_2n8zWTG2AzW8bCvU9z9joLzcwzVjLmvslVF39pE8,16022
 supervisely/function_wrapper.py,sha256=R5YajTQ0GnRp2vtjwfC9hINkzQc0JiyGsu8TER373xY,1912
 supervisely/sly_logger.py,sha256=LG1wTyyctyEKuCuKM2IKf_SMPH7BzkTsFdO-0tnorzg,6225
 supervisely/tiny_timer.py,sha256=hkpe_7FE6bsKL79blSs7WBaktuPavEVu67IpEPrfmjE,183
@@ -32,7 +32,7 @@ supervisely/api/image_api.py,sha256=qZwTjeCo6bkEuXDuB8RhhP0g6PzlRuCXJkUfN9rsUZ4,
 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=Jc_nf5ZgQdzcLYVbt6Vx7IT7KvXOKNqVIETXuewhnpg,43359
+supervisely/api/module_api.py,sha256=HrHndEvG684ULGchmFiFx0VsbSoihkq97iFPBFMY-dM,44345
 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
@@ -45,11 +45,11 @@ supervisely/api/storage_api.py,sha256=FPGYf3Rn3LBoe38RBNdoiURs306oshzvKOEOQ56XAb
 supervisely/api/task_api.py,sha256=yX0GqL5Kg5DuPXP0GpoRSVmjrzSzIvMMHo5Lrf4_R1c,39610
 supervisely/api/team_api.py,sha256=bEoz3mrykvliLhKnzEy52vzdd_H8VBJCpxF-Bnek9Q8,19467
 supervisely/api/user_api.py,sha256=4S97yIc6AMTZCa0N57lzETnpIE8CeqClvCb6kjUkgfc,24940
-supervisely/api/video_annotation_tool_api.py,sha256=Uy1MvT-M7vjC6y-0-V4wFCO-fZt8_aWneNiEJgr_jhU,5133
+supervisely/api/video_annotation_tool_api.py,sha256=3A9-U8WJzrTShP_n9T8U01M9FzGYdeS51CCBTzUnooo,6686
 supervisely/api/workspace_api.py,sha256=5KAxpI9DKBmgF_pyQaXHpGT30HZ9wRtR6DP3FoYFZtY,9228
 supervisely/api/entity_annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/api/entity_annotation/entity_annotation_api.py,sha256=K79KdDyepQv4FiNQHBj9V4-zLIemxK9WG1ig1bfBKb8,3083
-supervisely/api/entity_annotation/figure_api.py,sha256=_JS1x0jn5neoCnZCBKHUBwspoHg92N-sJ9Ty9h07Mvg,24427
+supervisely/api/entity_annotation/figure_api.py,sha256=deYCZNG7JeDhxlYew51FyGvqY3dc7fkERtwmBPJmHcw,24503
 supervisely/api/entity_annotation/object_api.py,sha256=gbcNvN_KY6G80Me8fHKQgryc2Co7VU_kfFd1GYILZ4E,8875
 supervisely/api/entity_annotation/tag_api.py,sha256=M-28m9h8R4k9Eqo6P1S0UH8_D5kqCwAvQLYY6_Yz4oM,11161
 supervisely/api/pointcloud/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -64,7 +64,7 @@ supervisely/api/pointcloud/pointcloud_object_api.py,sha256=bO1USWb9HAywG_CW4CDu1
 supervisely/api/pointcloud/pointcloud_tag_api.py,sha256=iShtr052nOElxsyMyZEUT2vypEm6kP00gnP13ABX24A,4691
 supervisely/api/video/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/api/video/video_annotation_api.py,sha256=nvbn_ofcqFCZ2qKgu0O5y5zOHxFc4tsY-o93sUgqlWk,14134
-supervisely/api/video/video_api.py,sha256=KO_Nfqa4xDWrc7FqOR14PciC0TX8PF0g0peqgPnctEE,94677
+supervisely/api/video/video_api.py,sha256=ma33Et1LKlACpyvksBYG9tbGNV_1ZSEuSAAsYpLP8qU,94666
 supervisely/api/video/video_figure_api.py,sha256=quksohjhgrK2l2-PtbbNE99fOW6uWXX59-_4xfc-I-k,6244
 supervisely/api/video/video_frame_api.py,sha256=4GwSI4xdCNYEUvTqzKc-Ewd44fw5zqkFoD24jrrN_aY,10214
 supervisely/api/video/video_object_api.py,sha256=IC0NP8EoIT_d3xxDRgz2cA3ixSiuJ5ymy64eS-RfmDM,2227
@@ -93,7 +93,7 @@ supervisely/app/fastapi/index.html,sha256=wMMWSRCoVeOnIJYUHR6Aj-jebOuian963Si-cz
 supervisely/app/fastapi/no_html_main.html,sha256=NhQP7noyORBx72lFh1CQKgBRupkWjiq6Gaw-9Hkvg7c,37
 supervisely/app/fastapi/offline.py,sha256=CwMMkJ1frD6wiZS-SEoNDtQ1UJcJe1Ob6ohE3r4CQL8,7414
 supervisely/app/fastapi/request.py,sha256=NU7rKmxJ1pfkDZ7_yHckRcRAueJRQIqCor11UO2OHr8,766
-supervisely/app/fastapi/subapp.py,sha256=jjEfqNUjlwiNKFf9UKOHmVO1vGgvGjE-R_oyN0WFUbk,43561
+supervisely/app/fastapi/subapp.py,sha256=MlB2dcHEtF0RPk-hxk67Gb1wBeGHsgCEIqAaBHzLEoY,43653
 supervisely/app/fastapi/templating.py,sha256=sxp8QMYfWd6ARDTl6c4JqY985-BSkM_WLxHEH2kv3bg,2929
 supervisely/app/fastapi/utils.py,sha256=GZuTWLcVRGVx8TL3jVEYUOZIT2FawbwIe2kAOBLw9ho,398
 supervisely/app/fastapi/websocket.py,sha256=TlRSPOAhRItTv1HGvdukK1ZvhRjMUxRa-lJlsRR9rJw,1308
@@ -871,8 +871,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=_pPSpkl8Wkqkiidn0vu6kWE19cngd80av--jncHxMEQ,30510
-supervisely/nn/inference/inference.py,sha256=IDkMFsURnB-vBM-2Kf-M7D5IQw6VUoIwVoh_IIdzA9Q,143958
+supervisely/nn/inference/cache.py,sha256=h-pP_7th0ana3oJ75sFfTbead3hdKUvYA8Iq2OXDx3I,31317
+supervisely/nn/inference/inference.py,sha256=WsxKGawOxxziL5sGQebN_KQ5hi22lZOGXODOM5ev1uE,144908
 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
@@ -905,13 +905,14 @@ 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=EBEwLczXugCSYaIUFxB33h7SOIkPDEBWLhr_TbASNOA,17441
+supervisely/nn/inference/tracking/base_tracking.py,sha256=OW7Rt7MIoyKvMEFBMpdCp80Kj7cLoZ3bkYE4YaYtN0I,13865
+supervisely/nn/inference/tracking/bbox_tracking.py,sha256=sPE-jZjSKf5QuMXmYUOkP1N6guOHK1_MvXK30MapB8A,21090
 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/mask_tracking.py,sha256=1G0yHMw5BSzDGD4Ps-yRhr50ZeB88pMY6b-rmg2FFHw,25576
 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/point_tracking.py,sha256=I0kT_YGqOudyX4LMSZfnWkB1UnUQ9ucawTyR-tFonc8,24644
 supervisely/nn/inference/tracking/tracker3d_interface.py,sha256=7yIkNO9rgkzQuyXUUccLwqlv5k7RPbxTqz9uI4FylLE,2781
-supervisely/nn/inference/tracking/tracker_interface.py,sha256=FXI9f0I5Tb5HN7l8fvxJ5wJ-QYuKyxfXiDpfXRLsSq4,10766
+supervisely/nn/inference/tracking/tracker_interface.py,sha256=lrIo6ULa4GYd_QclALt82k5d9cLpH0Ss3--XFhPBgUQ,21913
 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
@@ -1070,9 +1071,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.284.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.284.dist-info/METADATA,sha256=GriDRRnOtHK84_HcMIMCD6z4qfCCZSHH5NyJsTmW3e4,33573
-supervisely-6.73.284.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-supervisely-6.73.284.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.284.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.284.dist-info/RECORD,,
+supervisely-6.73.286.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.286.dist-info/METADATA,sha256=ulxDJ50Pdv9rflRKXgqgB8fpw1pOMrd4xzC1uDdIseU,33573
+supervisely-6.73.286.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+supervisely-6.73.286.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.286.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.286.dist-info/RECORD,,