supervisely 6.73.261__tar.gz → 6.73.262__tar.gz

{supervisely-6.73.261/supervisely.egg-info → supervisely-6.73.262}/PKG-INFO

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

{supervisely-6.73.261 → supervisely-6.73.262}/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-6.73.261 → supervisely-6.73.262}/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-6.73.261 → supervisely-6.73.262}/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-6.73.261 → supervisely-6.73.262}/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 → supervisely-6.73.262/supervisely.egg-info}/PKG-INFO

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