supervisely 6.73.438__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/nn/inference/inference_request.py

@@ -5,23 +5,19 @@ import time
 import traceback
 import uuid
 from concurrent.futures import Future, ThreadPoolExecutor
-from functools import partial, wraps
+from functools import partial
 from typing import Any, Dict, List, Tuple, Union
 
-from supervisely._utils import rand_str
 from supervisely.nn.utils import get_gpu_usage, get_ram_usage
 from supervisely.sly_logger import logger
 from supervisely.task.progress import Progress
 
 
-def generate_uuid(self) -> str:
-    """
-    Generates a unique UUID for the inference request.
-    """
-    return uuid.uuid5(namespace=uuid.NAMESPACE_URL, name=f"{time.time()}-{rand_str(10)}").hex
-
-
 class InferenceRequest:
+    PAUSE_SLEEP_INTERVAL = 1.0
+    PAUSE_SLEEP_MAX_WAIT = 60 * 60  # 1 hour
+    PENDING_RESULTS_MAX_SIZE = 500
+
     class Stage:
         PREPARING = "Preparing model for inference..."
         INFERENCE = "Running inference..."
@@ -47,6 +43,10 @@ class InferenceRequest:
         self._final_result = None
         self._exception = None
         self._stopped = threading.Event()
+        self._paused_time = None
+        self._paused = threading.Event()
+        self._progress_log_interval = 5.0
+        self._last_progress_report_time = 0
         self.progress = Progress(
             message=self._stage,
             total_cnt=1,
@@ -58,6 +58,8 @@ class InferenceRequest:
         self._updated_at = self._created_at
         self._finished = False
 
+        self.tracker = None
+
         self.global_progress = None
         self.global_progress_total = 1
         self.global_progress_current = 0
@@ -95,10 +97,16 @@ class InferenceRequest:
     def add_results(self, results: List[Dict]):
         with self._lock:
             self._pending_results.extend(results)
+            if self.pending_num() >= self.PENDING_RESULTS_MAX_SIZE:
+                logger.warning(
+                    f"Pending results exceeded max size {self.PENDING_RESULTS_MAX_SIZE}, pausing inference request {self._uuid} for {self.PAUSE_SLEEP_MAX_WAIT} seconds."
+                )
+                self.pause()
             self._updated()
 
     def pop_pending_results(self, n: int = None):
         with self._lock:
+            self.continue_if_paused()
             if len(self._pending_results) == 0:
                 return []
             if n is None:
@@ -135,9 +143,19 @@ class InferenceRequest:
                 )
             self._updated()
 
+    def set_progress_log_interval(self, interval: float):
+        self._progress_log_interval = interval
+
     def done(self, n=1):
         with self._lock:
-            self.progress.iters_done_report(n)
+            if (
+                self._progress_log_interval is None
+                or time.monotonic() - self._last_progress_report_time > self._progress_log_interval
+            ) or (self.progress.current + n >= self.progress.total):
+                self.progress.iters_done_report(n)
+                self._last_progress_report_time = time.monotonic()
+            else:
+                self.progress.iters_done(n)
             if self._stage == InferenceRequest.Stage.INFERENCE:
                 self.global_progress_current += n
                 if self.manager is not None:
@@ -164,6 +182,27 @@ class InferenceRequest:
     def is_stopped(self):
         return self._stopped.is_set()
 
+    def pause(self):
+        self._paused.set()
+        self._paused_time = time.monotonic()
+        self._updated()
+
+    def is_paused(self):
+        return self._paused.is_set()
+
+    def continue_if_paused(self):
+        if not self.is_paused():
+            return
+        logger.debug(f"Continuing paused inference request {self._uuid}")
+        self._paused.clear()
+        self._paused_time = None
+        self._updated()
+
+    def paused_for(self):
+        if not self.is_paused():
+            return 0
+        return time.monotonic() - self._paused_time
+
     def is_finished(self):
         return self._finished
 
@@ -200,6 +239,7 @@ class InferenceRequest:
             "exception": self.exception_json(),
             "is_inferring": self.is_inferring(),
             "stopped": self.is_stopped(),
+            "paused": self.is_paused(),
             "finished": self._finished,
             "created_at": self._created_at,
             "updated_at": self._updated_at,
@@ -353,6 +393,11 @@ class InferenceRequestsManager:
                 inference_request = self._inference_requests.get(inference_request_uuid)
                 if inference_request is None:
                     continue
+                if (
+                    inference_request.is_paused()
+                    and inference_request.paused_for() < InferenceRequest.PAUSE_SLEEP_MAX_WAIT
+                ):
+                    continue
                 if inference_request.is_expired():
                     self.remove(inference_request_uuid)
                     logger.debug(f"Expired inference request {inference_request_uuid} was deleted")

supervisely/nn/inference/predict_app/gui/classes_selector.py

@@ -1,10 +1,50 @@
-from typing import Dict, Any
-from supervisely.app.widgets import Button, Card, ClassesTable, Container, Text
-
-
+from typing import Any, Dict
+
+import pandas as pd
+
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    ClassesTable,
+    Container,
+    FastTable,
+    Text,
+)
+from supervisely.geometry.any_geometry import AnyGeometry
+from supervisely.geometry.bitmap import Bitmap
+from supervisely.geometry.cuboid import Cuboid
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.geometry.geometry import Geometry
+from supervisely.geometry.graph import GraphNodes
+from supervisely.geometry.multichannel_bitmap import MultichannelBitmap
+from supervisely.geometry.point import Point
+from supervisely.geometry.point_3d import Point3d
+from supervisely.geometry.pointcloud import Pointcloud
+from supervisely.geometry.polygon import Polygon
+from supervisely.geometry.polyline import Polyline
+from supervisely.geometry.rectangle import Rectangle
+from supervisely.geometry.oriented_bbox import OrientedBBox
+from supervisely.project.project_meta import ProjectMeta
+
+type_to_zmdi_icon = {
+    AnyGeometry: "zmdi zmdi-shape",
+    Rectangle: "zmdi zmdi-crop-din",  # "zmdi zmdi-square-o"
+    # sly.Polygon: "icons8-polygon",  # "zmdi zmdi-edit"
+    Polygon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABmJLR0QA/wD/AP+gvaeTAAAB6klEQVRYhe2Wuy8EURTGf+u5VESNXq2yhYZCoeBv8RcI1i6NVUpsoVCKkHjUGlFTiYb1mFmh2MiKjVXMudmb3cPOzB0VXzKZm5k53/nmvO6Ff4RHD5AD7gFP1l3Kd11AHvCBEpAVW2esAvWmK6t8l1O+W0lCQEnIJoAZxUnzNQNkZF36jrQjgoA+uaciCgc9VaExBOyh/6WWAi1VhbjOJ4FbIXkBtgkK0BNHnYqNKUIPeBPbKyDdzpld5T6wD9SE4AwYjfEDaXFeFzE/doUWuhqwiFsOCwqv2hV2lU/L+sHBscGTxdvSFVoXpAjCZdauMHVic6ndl6U1VBsJCFhTeNUU9IiIEo3qvQYGHAV0AyfC5wNLhKipXuBCjA5wT8WxcM1FMRoBymK44CjAE57hqIazwCfwQdARcXa3UXHuRXVucIjb7jYvNkdxBZg0TBFid7PQTRAtX2xOiXkuMAMqYwkIE848rZFbjyNAmw9bIeweaZ2A5TgC7PnwKkTPtN+cTOrsyN3FEWAjRTAX6sA5ek77gSL6+WHZVQDAIHAjhJtN78aAS3lXAXYIivBOnCdyOAUYB6o0xqsvziry7FLE/Cp20cNcJEjDr8MUmVOVRzkVN+Nd7vZGVXXgiwxtPiRS5WFhz4fEq/zv4AvToMn7vCn3eAAAAABJRU5ErkJggg==",
+    Bitmap: "zmdi zmdi-brush",
+    Polyline: "zmdi zmdi-gesture",
+    Point: "zmdi zmdi-dot-circle-alt",
+    Cuboid: "zmdi zmdi-ungroup",  #
+    GraphNodes: "zmdi zmdi-grain",
+    Cuboid3d: "zmdi zmdi-codepen",
+    Pointcloud: "zmdi zmdi-cloud-outline",  # "zmdi zmdi-border-clear"
+    MultichannelBitmap: "zmdi zmdi-layers",  # "zmdi zmdi-collection-item"
+    Point3d: "zmdi zmdi-filter-center-focus",  # "zmdi zmdi-select-all"
+    OrientedBBox: "zmdi zmdi-rotate-cw",
+}
 class ClassesSelector:
-    title = "Classes Selector"
-    description = "Select classes that will be used for inference"
+    title = "Classes"
+    description = "Select classes that will be used for inference. This classes are defined by the deployed model"
     lock_message = "Select previous step to unlock"
 
     def __init__(self):
@@ -24,7 +64,9 @@ class ClassesSelector:
         # -------------------------------- #
 
         # Classes
-        self.classes_table = ClassesTable()
+        columns = ["class", "shape"]
+        self.classes_table = FastTable(columns=columns, page_size=100, is_selectable=True)
+        # self.classes_table = ClassesTable()
         self.classes_table.hide()
         # Add widgets to display ------------ #
         self.display_widgets.extend([self.classes_table])
@@ -45,25 +87,36 @@ class ClassesSelector:
             content=self.container,
             lock_message=self.lock_message,
         )
-        self.card.lock()
         # -------------------------------- #
 
+    def lock(self):
+        self.card.lock()
+        self.classes_table.hide()
+        self.validator_text.hide()
+
+    def unlock(self):
+        self.card.unlock()
+        self.classes_table.show()
+
     @property
     def widgets_to_disable(self) -> list:
         return [self.classes_table]
 
+    def set_project_meta(self, project_meta) -> None:
+        self._update_meta(project_meta)
+
     def load_from_json(self, data: Dict[str, Any]) -> None:
         if "classes" in data:
             self.set_classes(data["classes"])
 
     def get_selected_classes(self) -> list:
-        return self.classes_table.get_selected_classes()
+        return [row.row[0] for row in self.classes_table.get_selected_rows()]
 
     def set_classes(self, classes) -> None:
-        self.classes_table.select_classes(classes)
+        self.classes_table.select_rows_by_value("class", classes)
 
     def select_all_classes(self) -> None:
-        self.classes_table.select_all()
+        self.classes_table.select_rows(list(range(len(self.classes_table._rows_total))))
 
     def get_settings(self) -> Dict[str, Any]:
         return {"classes": self.get_selected_classes()}
@@ -73,7 +126,7 @@ class ClassesSelector:
             return True
 
         self.validator_text.hide()
-        selected_classes = self.classes_table.get_selected_classes()
+        selected_classes = self.get_selected_classes()
         n_classes = len(selected_classes)
 
         if n_classes == 0:
@@ -89,3 +142,21 @@ class ClassesSelector:
         self.validator_text.set(text=". ".join(message_parts), status=status)
         self.validator_text.show()
         return is_valid
+
+    def _update_meta(self, project_meta: ProjectMeta) -> None:
+        table_data = []
+        for obj_class in project_meta.obj_classes:
+            table_line = []
+            name = obj_class.name
+            icon = type_to_zmdi_icon[AnyGeometry]
+            icon = type_to_zmdi_icon.get(obj_class.geometry_type, icon)
+            shape = obj_class.geometry_type.geometry_name().lower()
+            if shape == "graph":
+                shape = "graph (keypoints)"
+            table_line = [name, shape]
+            table_data.append(table_line)
+        self._table_data = table_data
+        if self._table_data:
+            self.classes_table.read_pandas(pd.DataFrame(self._table_data))
+        else:
+            self.classes_table.clear()