supervisely 6.73.357__py3-none-any.whl → 6.73.359__py3-none-any.whl

supervisely/nn/inference/cache.py

@@ -1,12 +1,13 @@
 import json
 import shutil
+import tempfile
 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 typing import Any, Callable, Generator, List, Optional, Tuple, Union
+from typing import Any, BinaryIO, Callable, Generator, List, Optional, Tuple, Union
 
 import cv2
 import numpy as np
@@ -15,8 +16,10 @@ from cachetools import Cache, LRUCache, TTLCache
 from fastapi import BackgroundTasks, FastAPI, Form, Request, UploadFile
 
 import supervisely as sly
+import supervisely.io.env as env
 from supervisely._utils import batched
 from supervisely.io.fs import silent_remove
+from supervisely.video.video import VideoFrameReader
 
 
 class PersistentImageLRUCache(LRUCache):
@@ -139,16 +142,26 @@ class PersistentImageTTLCache(TTLCache):
         if rm_base_folder:
             shutil.rmtree(self._base_dir)
 
-    def save_image(self, key, image: np.ndarray) -> None:
+    def save_image(self, key, image: Union[np.ndarray, BinaryIO, bytes], ext=".png") -> None:
         if not self._base_dir.exists():
             self._base_dir.mkdir()
 
-        filepath = self._base_dir / f"{str(key)}.png"
+        if ext is None or ext == "":
+            ext = ".png"
+
+        filepath = self._base_dir / Path(key).with_suffix(ext)
         self[key] = filepath
 
         if filepath.exists():
             sly.logger.debug(f"Rewrite image {str(filepath)}")
-        sly.image.write(str(filepath), image)
+        if isinstance(image, np.ndarray):
+            sly.image.write(str(filepath), image)
+        elif isinstance(image, bytes):
+            with open(filepath, "wb") as f:
+                f.write(image)
+        else:
+            with open(filepath, "wb") as f:
+                shutil.copyfileobj(image, f)
 
     def get_image_path(self, key: Any) -> Path:
         return self[key]
@@ -156,16 +169,25 @@ class PersistentImageTTLCache(TTLCache):
     def get_image(self, key: Any):
         return sly.image.read(str(self[key]))
 
-    def save_video(self, video_id: int, src_video_path: str) -> None:
-        ext = Path(src_video_path).suffix
-        video_path = self._base_dir / f"video_{video_id}{ext}"
-        self[video_id] = video_path
-        if src_video_path != str(video_path):
-            shutil.move(src_video_path, str(video_path))
-        sly.logger.debug(f"Video #{video_id} saved to {video_path}", extra={"video_id": video_id})
+    def save_video(self, key: Any, source: Union[str, Path, BinaryIO]) -> None:
+        ext = ""
+        if isinstance(source, Path):
+            ext = source.suffix
+        elif isinstance(source, str):
+            ext = Path(source).suffix
+        video_path = self._base_dir / f"video_{key}{ext}"
+        self[key] = video_path
+
+        if isinstance(source, (str, Path)):
+            if str(source) != str(video_path):
+                shutil.move(source, str(video_path))
+        else:
+            with open(video_path, "wb") as f:
+                shutil.copyfileobj(source, f)
+        sly.logger.debug(f"Video #{key} saved to {video_path}", extra={"video_id": key})
 
-    def get_video_path(self, video_id: int) -> Path:
-        return self[video_id]
+    def get_video_path(self, key: Any) -> Path:
+        return self[key]
 
     def save_project_meta(self, key, value):
         self[key] = value
@@ -177,35 +199,6 @@ class PersistentImageTTLCache(TTLCache):
         shutil.copyfile(str(self[name]), path)
 
 
-class VideoFrameReader:
-    def __init__(self, video_path: str, frame_indexes: List[int]):
-        self.video_path = video_path
-        self.frame_indexes = frame_indexes
-        self.cap = None
-        self.prev_idx = -1
-
-    def __enter__(self):
-        self.cap = cv2.VideoCapture(str(self.video_path))
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.cap is not None:
-            self.cap.release()
-
-    def read_frames(self) -> Generator:
-        try:
-            for frame_index in self.frame_indexes:
-                if frame_index != self.prev_idx + 1:
-                    self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_index)
-                ret, frame = self.cap.read()
-                if not ret:
-                    raise KeyError(f"Frame {frame_index} not found in video {self.video_path}")
-                yield cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                self.prev_idx = frame_index
-        finally:
-            self.cap.release()
-
-
 class InferenceImageCache:
     class _LoadType(Enum):
         ImageId: str = "IMAGE"
@@ -218,7 +211,7 @@ class InferenceImageCache:
         maxsize: int,
         ttl: int,
         is_persistent: bool = True,
-        base_folder: str = sly.env.smart_cache_container_dir(),
+        base_folder: str = env.smart_cache_container_dir(),
         log_progress: bool = False,
     ) -> None:
         self.is_persistent = is_persistent
@@ -227,6 +220,7 @@ class InferenceImageCache:
         self._lock = Lock()
         self._load_queue = CacheOut(ttl=10 * 60)
         self.log_progress = log_progress
+        self._download_executor = ThreadPoolExecutor(max_workers=5)
 
         if is_persistent:
             self._data_dir = Path(base_folder)
@@ -297,7 +291,7 @@ class InferenceImageCache:
     def _read_frames_from_cached_video_iter(self, video_id, frame_indexes):
         video_path = self._cache.get_video_path(video_id)
         with VideoFrameReader(video_path, frame_indexes) as reader:
-            for frame in reader.read_frames():
+            for frame in reader.iterate_frames():
                 yield frame
 
     def _read_frames_from_cached_video(
@@ -317,6 +311,33 @@ class InferenceImageCache:
         if frame is None:
             raise KeyError(f"Frame {frame_index} not found in video {video_id}")
 
+    def get_video_frames_count(self, key):
+        """
+        Returns number of frames in the video
+        """
+        if not isinstance(self._cache, PersistentImageTTLCache):
+            raise ValueError("Video frames count can be obtained only for persistent cache")
+        video_path = self._cache.get_video_path(key)
+        return VideoFrameReader(video_path).frames_count()
+
+    def get_video_frame_size(self, key):
+        """
+        Returns height and width of the video frame. (h, w)
+        """
+        if not isinstance(self._cache, PersistentImageTTLCache):
+            raise ValueError("Video frame size can be obtained only for persistent cache")
+        video_path = self._cache.get_video_path(key)
+        return VideoFrameReader(video_path).frame_size()
+
+    def get_video_fps(self, key):
+        """
+        Returns fps of the video
+        """
+        if not isinstance(self._cache, PersistentImageTTLCache):
+            raise ValueError("Video fps can be obtained only for persistent cache")
+        video_path = self._cache.get_video_path(key)
+        return VideoFrameReader(video_path).fps()
+
     def get_frames_from_cache(self, video_id: int, frame_indexes: List[int]) -> List[np.ndarray]:
         if isinstance(self._cache, PersistentImageTTLCache) and video_id in self._cache:
             return self._read_frames_from_cached_video(video_id, frame_indexes)
@@ -371,25 +392,32 @@ class InferenceImageCache:
     ) -> List[np.ndarray]:
         return_images = kwargs.get("return_images", True)
         redownload_video = kwargs.get("redownload_video", False)
+        progress_cb = kwargs.get("progress_cb", None)
 
         if video_id in self._cache:
             try:
-                return self.get_frames_from_cache(video_id, frame_indexes)
+                frames = self.get_frames_from_cache(video_id, frame_indexes)
+                if progress_cb is not None:
+                    progress_cb(len(frame_indexes))
+                if return_images:
+                    return frames
             except:
                 sly.logger.warning(
                     f"Frames {frame_indexes} not found in video {video_id}", exc_info=True
                 )
-                Thread(
-                    target=self.download_video,
-                    args=(api, video_id),
-                    kwargs={**kwargs, "return_images": False},
-                ).start()
+                self._download_executor.submit(
+                    self.download_video,
+                    api,
+                    video_id,
+                    **{**kwargs, "return_images": False},
+                )
         elif redownload_video:
-            Thread(
-                target=self.download_video,
-                args=(api, video_id),
-                kwargs={**kwargs, "return_images": False},
-            ).start()
+            self._download_executor.submit(
+                self.download_video,
+                api,
+                video_id,
+                **{**kwargs, "return_images": False},
+            )
 
         def name_constuctor(frame_index: int):
             return self._frame_name(video_id, frame_index)
@@ -403,34 +431,56 @@ class InferenceImageCache:
             load_generator,
             api.logger,
             return_images,
+            progress_cb=progress_cb,
+            video_id=video_id,
         )
 
-    def add_video_to_cache(self, video_id: int, video_path: Path) -> None:
+    def add_video_to_cache_by_io(self, video_id: int, video_io: BinaryIO) -> None:
+        if isinstance(self._cache, PersistentImageTTLCache):
+            with self._lock:
+                self._cache.save_video(video_id, source=video_io)
+
+    def add_video_to_cache(self, video_id: int, source: Union[str, Path, BinaryIO]) -> None:
         """
         Adds video to cache.
         """
         if isinstance(self._cache, PersistentImageTTLCache):
             with self._lock:
-                self._cache.save_video(video_id, str(video_path))
+                self._cache.save_video(video_id, source)
                 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
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            while cap.isOpened():
-                while self._frame_name(video_id, frame_index) in self._cache:
-                    frame_index += 1
-                if frame_index >= total_frames:
-                    break
-                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_index)
-                ret, frame = cap.read()
-                if not ret:
-                    break
-                frame = np.array(frame)
-                self.add_frame_to_cache(frame, video_id, frame_index)
-                frame_index = int(cap.get(cv2.CAP_PROP_POS_FRAMES))
-            cap.release()
+            tmp_source = None
+            if not isinstance(source, (str, Path)):
+                with tempfile.NamedTemporaryFile(delete=False) as f:
+                    shutil.copyfileobj(source, f)
+                    tmp_source = f.name
+                    source = tmp_source
+            try:
+                with VideoFrameReader(source) as reader:
+                    for frame_index, frame in enumerate(reader):
+                        self.add_frame_to_cache(frame, video_id, frame_index)
+            finally:
+                if tmp_source is not None:
+                    silent_remove(tmp_source)
+
+    def add_image_to_cache(
+        self, key: str, image: Union[np.ndarray, BinaryIO, bytes], ext=None
+    ) -> np.ndarray:
+        """
+        Adds image to cache.
+        """
+        with self._lock:
+            self._cache.save_image(key, image, ext)
+            self._load_queue.delete(key)
+            sly.logger.debug(f"Image {key} added to cache", extra={"image_id": key})
+            return self._cache.get_image(key)
+
+    def get_image_path(self, key) -> str:
+        return str(self._cache.get_image_path(key))
+
+    def get_video_path(self, key) -> str:
+        return str(self._cache.get_video_path(key))
 
     def download_video(self, api: sly.Api, video_id: int, **kwargs) -> None:
         """
@@ -621,8 +671,7 @@ class InferenceImageCache:
             state["video_id"] = video_id
             state["frame_ranges"] = list_of_ids_ranges_or_hashes
 
-        thread = Thread(target=self.cache_task, kwargs={"api": api, "state": state})
-        thread.start()
+        self._download_executor.submit(self.cache_task, api=api, state=state)
 
     def set_project_meta(self, project_id, project_meta):
         pr_meta_name = self._project_meta_name(project_id)
@@ -725,49 +774,65 @@ class InferenceImageCache:
         ],
         logger: Logger,
         return_images: bool = True,
+        progress_cb=None,
+        video_id=None,
     ) -> Optional[List[np.ndarray]]:
-        indexes_to_load = []
         pos_by_name = {}
         all_frames = [None for _ in range(len(indexes))]
-        items = []
-
-        for pos, hash_or_id in enumerate(indexes):
-            name = name_cunstructor(hash_or_id)
-            self._wait_if_in_queue(name, logger)
-
-            if name not in self._cache:
-                self._load_queue.set(name, hash_or_id)
-                indexes_to_load.append(hash_or_id)
-                pos_by_name[name] = pos
-            elif return_images is True:
-                items.append((pos, name))
 
         def get_one_image(item):
-            pos, name = item
-            return pos, self._cache.get_image(name)
-
-        if len(items) > 0:
-            with ThreadPoolExecutor(min(64, len(items))) as executor:
-                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)
-                self._add_to_cache(name, image)
+            pos, index = item
+            if video_id in self._cache:
+                return pos, self.get_frame_from_cache(video_id, index)
+            return pos, self._cache.get_image(name_cunstructor(index))
+
+        position = 0
+        batch_size = 4
+        for batch in batched(indexes, batch_size):
+            indexes_to_load = []
+            items = []
+            for hash_or_id in batch:
+                name = name_cunstructor(hash_or_id)
+                self._wait_if_in_queue(name, logger)
+
+                if name not in self._cache and video_id not in self._cache:
+                    self._load_queue.set(name, hash_or_id)
+                    indexes_to_load.append(hash_or_id)
+                    pos_by_name[name] = position
+                elif return_images is True:
+                    items.append((position, hash_or_id))
+                position += 1
+
+            if len(items) > 0:
+                with ThreadPoolExecutor(min(64, len(items))) as executor:
+                    for pos, image in executor.map(get_one_image, items):
+                        all_frames[pos] = image
+                        if progress_cb is not None:
+                            progress_cb()
 
-                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} 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)}")
+            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)
+                    self._add_to_cache(name, image)
+
+                    if return_images:
+                        pos = pos_by_name[name]
+                        all_frames[pos] = image
+                        if progress_cb is not None:
+                            progress_cb()
+            download_time = time.monotonic() - download_time
+
+            # logger.debug(f"All stored files: {sorted(os.listdir(self.tmp_path))}")
+            if indexes_to_load:
+                indexes_to_load = list(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},
+                )
+            found = set(batch).difference(indexes_to_load)
+            if found:
+                logger.debug(f"Images/Frames found in cache: {list(found)}")
 
         if return_images:
             return all_frames
@@ -803,7 +868,7 @@ class InferenceImageCache:
             frame_index_to_path = {}
             for frame_index, path in zip(this_frame_indexes[:5], this_paths[:5]):
                 frame_index_to_path[frame_index] = path
-                futures.append(executor.submit(_download_frame, frame_index))
+                futures.append(self._download_executor.submit(_download_frame, frame_index))
             for future in as_completed(futures):
                 frame_index, name = future.result()
                 path = frame_index_to_path[frame_index]
@@ -815,5 +880,4 @@ class InferenceImageCache:
 
         # optimization for frame read from video file
         frame_indexes, paths = zip(*sorted(zip(frame_indexes, paths), key=lambda x: x[0]))
-        executor = ThreadPoolExecutor(max_workers=5)
         _download_and_save(frame_indexes, paths)

supervisely/nn/inference/gui/gui.py

@@ -5,9 +5,10 @@
 from functools import wraps
 from typing import Callable, Dict, List, Optional, Union
 
+import yaml
+
 import supervisely.app.widgets as Widgets
 import supervisely.io.env as env
-import yaml
 from supervisely import Api
 from supervisely._utils import abs_url, is_debug_with_sly_net, is_development
 from supervisely.api.file_api import FileApi
@@ -96,9 +97,7 @@ class InferenceGUI(BaseInferenceGUI):
         self._serve_button = Widgets.Button("SERVE")
         self._success_label = Widgets.DoneLabel()
         self._success_label.hide()
-        self._download_progress = Widgets.Progress(
-            "Downloading model...", hide_on_finish=True
-        )
+        self._download_progress = Widgets.Progress("Downloading model...", hide_on_finish=True)
         self._download_progress.hide()
         self._change_model_button = Widgets.Button(
             "STOP AND CHOOSE ANOTHER MODEL", button_type="danger"
@@ -124,9 +123,7 @@ class InferenceGUI(BaseInferenceGUI):
         self._model_classes_widget = Widgets.ClassesTable(selectable=False)
         self._model_classes_plug = Widgets.Text("No classes provided")
         self._model_classes_widget_container = Widgets.Field(
-            content=Widgets.Container(
-                [self._model_classes_widget, self._model_classes_plug]
-            ),
+            content=Widgets.Container([self._model_classes_widget, self._model_classes_plug]),
             title="Model classes",
             description="List of classes model predicts",
         )
@@ -155,9 +152,7 @@ class InferenceGUI(BaseInferenceGUI):
 
         self._model_full_info_card.collapse()
         self._additional_ui_content = []
-        self.get_ui = self.__add_content_and_model_info_to_default_ui(
-            self._model_full_info_card
-        )
+        self.get_ui = self.__add_content_and_model_info_to_default_ui(self._model_full_info_card)
 
         tabs_titles = []
         tabs_contents = []
@@ -171,9 +166,7 @@ class InferenceGUI(BaseInferenceGUI):
                 def update_table(selected_model):
                     cols = [
                         model_key
-                        for model_key in self._models[selected_model]["checkpoints"][
-                            0
-                        ].keys()
+                        for model_key in self._models[selected_model]["checkpoints"][0].keys()
                     ]
                     rows = [
                         [value for param_name, value in model.items()]
@@ -262,9 +255,7 @@ class InferenceGUI(BaseInferenceGUI):
             custom_tab_content = Widgets.Container(custom_tab_widgets)
             tabs_titles.append("Custom models")
             tabs_contents.append(custom_tab_content)
-            tabs_descriptions.append(
-                "Models trained in Supervisely and located in Team Files"
-            )
+            tabs_descriptions.append("Models trained in Supervisely and located in Team Files")
 
         self._tabs = Widgets.RadioTabs(
             titles=tabs_titles,
@@ -272,9 +263,7 @@ class InferenceGUI(BaseInferenceGUI):
             descriptions=tabs_descriptions,
         )
 
-        self.on_change_model_callbacks: List[CallbackT] = [
-            InferenceGUI._hide_info_after_change
-        ]
+        self.on_change_model_callbacks: List[CallbackT] = [InferenceGUI._hide_info_after_change]
         self.on_serve_callbacks: List[CallbackT] = []
 
         @self.serve_button.click
@@ -302,7 +291,9 @@ class InferenceGUI(BaseInferenceGUI):
             self._models_table.enable()
         if self._support_custom_models:
             self._model_path_input.enable()
-        Progress("model deployment canceled", 1).iter_done_report()
+        # @TODO: Ask web team to add message to list of request ready messages
+        # Progress("model deployment canceled", 1).iter_done_report()
+        Progress("Application is started ...", 1).iter_done_report()
 
     def _hide_info_after_change(self):
         self._model_full_info_card.collapse()
@@ -345,9 +336,7 @@ class InferenceGUI(BaseInferenceGUI):
 
         table_subtitles, cols = self._get_table_subtitles(cols)
         if self._models_table is None:
-            self._models_table = Widgets.RadioTable(
-                cols, rows, subtitles=table_subtitles
-            )
+            self._models_table = Widgets.RadioTable(cols, rows, subtitles=table_subtitles)
         else:
             self._models_table.set_data(cols, rows, subtitles=table_subtitles)
 
@@ -441,7 +430,7 @@ class InferenceGUI(BaseInferenceGUI):
 
     def set_project_meta(self, inference):
         if self._get_classes_from_inference(inference) is None:
-            logger.warn("Skip loading project meta.")
+            logger.warning("Skip loading project meta.")
             self._model_classes_widget.hide()
             self._model_classes_plug.show()
             return
@@ -476,28 +465,22 @@ class InferenceGUI(BaseInferenceGUI):
     #             self.show_deployed_model_info(inference)
 
     #     else:
-    #         logger.warn("Failed to create handler for models table")
+    #         logger.warning("Failed to create handler for models table")
 
     def _get_classes_from_inference(self, inference) -> Optional[List[str]]:
         classes = None
         try:
             classes = inference.get_classes()
         except NotImplementedError:
-            logger.warn(
-                f"get_classes() function not implemented for {type(inference)} object."
-            )
+            logger.warning(f"get_classes() function not implemented for {type(inference)} object.")
         except AttributeError:
-            logger.warn(
-                "Probably, get_classes() function not working without model deploy."
-            )
+            logger.warning("Probably, get_classes() function not working without model deploy.")
         except Exception as exc:
-            logger.warn("Skip getting classes info due to exception")
+            logger.warning("Skip getting classes info due to exception")
             logger.exception(exc)
 
         if classes is None or len(classes) == 0:
-            logger.warn(
-                f"get_classes() function return {classes}; skip classes processing."
-            )
+            logger.warning(f"get_classes() function return {classes}; skip classes processing.")
             return None
         return classes
 

supervisely/nn/inference/gui/serving_gui.py

@@ -129,7 +129,9 @@ class ServingGUI:
         self._device_select._select.enable()
         self._device_select.enable()
         self._change_model_button.hide()
-        Progress("model deployment canceled", 1).iter_done_report()
+        # @TODO: Ask web team to add message to list of request ready messages
+        # Progress("model deployment canceled", 1).iter_done_report()
+        Progress("Application is started ...", 1).iter_done_report()
 
     def _hide_info_after_change(self):
         self._model_full_info_card.collapse()