supervisely 6.73.459__py3-none-any.whl → 6.73.468__py3-none-any.whl

supervisely/nn/inference/inference.py

@@ -11,6 +11,7 @@ import subprocess
 import tempfile
 import threading
 import time
+import uuid
 from collections import OrderedDict, defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import asdict, dataclass
@@ -52,6 +53,7 @@ from supervisely.annotation.tag_meta import TagMeta, TagValueType
 from supervisely.api.api import Api, ApiField
 from supervisely.api.app_api import WorkflowMeta, WorkflowSettings
 from supervisely.api.image_api import ImageInfo
+from supervisely.api.video.video_api import VideoInfo
 from supervisely.app.content import get_data_dir
 from supervisely.app.fastapi.subapp import (
     Application,
@@ -102,6 +104,11 @@ from supervisely.video_annotation.video_figure import VideoFigure
 from supervisely.video_annotation.video_object import VideoObject
 from supervisely.video_annotation.video_object_collection import VideoObjectCollection
 from supervisely.video_annotation.video_tag_collection import VideoTagCollection
+from supervisely.video_annotation.key_id_map import KeyIdMap
+from supervisely.video_annotation.video_object_collection import (
+    VideoObject,
+    VideoObjectCollection,
+)
 
 try:
     from typing import Literal
@@ -435,7 +442,7 @@ class Inference:
 
                 device = "cuda" if torch.cuda.is_available() else "cpu"
             except Exception as e:
-                logger.warn(
+                logger.warning(
                     f"Device auto detection failed, set to default 'cpu', reason: {repr(e)}"
                 )
                 device = "cpu"
@@ -1367,6 +1374,7 @@ class Inference:
 
         if tracker == "botsort":
             from supervisely.nn.tracker import BotSortTracker
+
             device = tracker_settings.get("device", self.device)
             logger.debug(f"Initializing BotSort tracker with device: {device}")
             return BotSortTracker(settings=tracker_settings, device=device)
@@ -1383,15 +1391,15 @@ class Inference:
             if classes is not None:
                 num_classes = len(classes)
         except NotImplementedError:
-            logger.warn(f"get_classes() function not implemented for {type(self)} object.")
+            logger.warning(f"get_classes() function not implemented for {type(self)} 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("Unknown exception. Please, contact support")
+            logger.warning("Unknown exception. Please, contact support")
             logger.exception(exc)
 
         if num_classes is None:
-            logger.warn(f"get_classes() function return {classes}; skip classes processing.")
+            logger.warning(f"get_classes() function return {classes}; skip classes processing.")
 
         return {
             "app_name": get_name_from_env(default="Neural Network Serving"),
@@ -1412,7 +1420,7 @@ class Inference:
     def get_tracking_settings(self) -> Dict[str, Dict[str, Any]]:
         """
         Get default parameters for all available tracking algorithms.
-        
+
         Returns:
             {"botsort": {"track_high_thresh": 0.6, ...}}
             Empty dict if tracking not supported.
@@ -1430,6 +1438,7 @@ class Inference:
             try:
                 if tracker_name == "botsort":
                     from supervisely.nn.tracker import BotSortTracker
+
                     trackers_params[tracker_name] = BotSortTracker.get_default_params()
                 # Add other trackers here as elif blocks
                 else:
@@ -1441,7 +1450,7 @@ class Inference:
         for tracker_name, params in trackers_params.items():
             trackers_params[tracker_name] = {
                 k: v for k, v in params.items() if k not in INTERNAL_FIELDS
-                }
+            }
         return trackers_params
 
     def get_human_readable_info(self, replace_none_with: Optional[str] = None):
@@ -2270,8 +2279,8 @@ class Inference:
                     frame_index=frame_index,
                     video_id=video_info.id,
                     dataset_id=video_info.dataset_id,
-                        project_id=video_info.project_id,
-                    )
+                    project_id=video_info.project_id,
+                )
                 for ann, frame_index in zip(anns, batch)
             ]
             for pred, this_slides_data in zip(predictions, slides_data):
@@ -2289,6 +2298,162 @@ class Inference:
         inference_request.final_result = {"video_ann": video_ann_json}
         return video_ann_json
 
+    def _tracking_by_detection(self, api: Api, state: dict, inference_request: InferenceRequest):
+        logger.debug("Inferring video_id...", extra={"state": state})
+        inference_settings = self._get_inference_settings(state)
+        logger.debug(f"Inference settings:", extra=inference_settings)
+        batch_size = self._get_batch_size_from_state(state)
+        video_id = get_value_for_keys(state, ["videoId", "video_id"], ignore_none=True)
+        if video_id is None:
+            raise ValueError("Video id is not provided")
+        video_info = api.video.get_info_by_id(video_id)
+        start_frame_index = get_value_for_keys(
+            state, ["startFrameIndex", "start_frame_index", "start_frame"], ignore_none=True
+        )
+        if start_frame_index is None:
+            start_frame_index = 0
+        step = get_value_for_keys(state, ["stride", "step"], ignore_none=True)
+        if step is None:
+            step = 1
+        end_frame_index = get_value_for_keys(
+            state, ["endFrameIndex", "end_frame_index", "end_frame"], ignore_none=True
+        )
+        duration = state.get("duration", None)
+        frames_count = get_value_for_keys(
+            state, ["framesCount", "frames_count", "num_frames"], ignore_none=True
+        )
+        tracking = state.get("tracker", None)
+        direction = state.get("direction", "forward")
+        direction = 1 if direction == "forward" else -1
+        track_id = get_value_for_keys(state, ["trackId", "track_id"], ignore_none=True)
+
+        if frames_count is not None:
+            n_frames = frames_count
+        elif end_frame_index is not None:
+            n_frames = end_frame_index - start_frame_index
+        elif duration is not None:
+            fps = video_info.frames_count / video_info.duration
+            n_frames = int(duration * fps)
+        else:
+            n_frames = video_info.frames_count
+
+        inference_request.tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
+
+        logger.debug(
+            f"Video info:",
+            extra=dict(
+                w=video_info.frame_width,
+                h=video_info.frame_height,
+                start_frame_index=start_frame_index,
+                n_frames=n_frames,
+            ),
+        )
+
+        # start downloading video in background
+        self.cache.run_cache_task_manually(api, None, video_id=video_id)
+
+        progress_total = (n_frames + step - 1) // step
+        inference_request.set_stage(InferenceRequest.Stage.INFERENCE, 0, progress_total)
+
+        _upload_f = partial(
+            self.upload_predictions_to_video,
+            api=api,
+            video_info=video_info,
+            track_id=track_id,
+            context=inference_request.context,
+            progress_cb=inference_request.done,
+            inference_request=inference_request,
+        )
+
+        _range = (start_frame_index, start_frame_index + direction * n_frames)
+        if _range[0] > _range[1]:
+            _range = (_range[1], _range[0])
+
+        def _notify_f(predictions: List[Prediction]):
+            logger.debug(
+                "Notifying tracking progress...",
+                extra={
+                    "track_id": track_id,
+                    "range": _range,
+                    "current": inference_request.progress.current,
+                    "total": inference_request.progress.total,
+                },
+            )
+            stopped = self.api.video.notify_progress(
+                track_id=track_id,
+                video_id=video_info.id,
+                frame_start=_range[0],
+                frame_end=_range[1],
+                current=inference_request.progress.current,
+                total=inference_request.progress.total,
+            )
+            if stopped:
+                inference_request.stop()
+                logger.info("Tracking has been stopped by user", extra={"track_id": track_id})
+
+        def _exception_handler(e: Exception):
+            self.api.video.notify_tracking_error(
+                track_id=track_id,
+                error=str(type(e)),
+                message=str(e),
+            )
+            raise e
+
+        with Uploader(
+            upload_f=_upload_f,
+            notify_f=_notify_f,
+            exception_handler=_exception_handler,
+            logger=logger,
+        ) as uploader:
+            for batch in batched(
+                range(
+                    start_frame_index, start_frame_index + direction * n_frames, direction * step
+                ),
+                batch_size,
+            ):
+                if inference_request.is_stopped():
+                    logger.debug(
+                        f"Cancelling inference video...",
+                        extra={"inference_request_uuid": inference_request.uuid},
+                    )
+                    break
+                logger.debug(
+                    f"Inferring frames {batch[0]}-{batch[-1]}:",
+                )
+                frames = self.cache.download_frames(
+                    api, video_info.id, batch, redownload_video=True
+                )
+                anns, slides_data = self._inference_auto(
+                    source=frames,
+                    settings=inference_settings,
+                )
+
+                if inference_request.tracker is not None:
+                    anns = self._apply_tracker_to_anns(frames, anns, inference_request.tracker)
+
+                predictions = [
+                    Prediction(
+                        ann,
+                        model_meta=self.model_meta,
+                        frame_index=frame_index,
+                        video_id=video_info.id,
+                        dataset_id=video_info.dataset_id,
+                        project_id=video_info.project_id,
+                    )
+                    for ann, frame_index in zip(anns, batch)
+                ]
+                for pred, this_slides_data in zip(predictions, slides_data):
+                    pred.extra_data["slides_data"] = this_slides_data
+                uploader.put(predictions)
+        video_ann_json = None
+        if inference_request.tracker is not None:
+            inference_request.set_stage("Postprocess...", 0, 1)
+            video_ann_json = inference_request.tracker.video_annotation.to_json()
+            inference_request.done()
+        inference_request.final_result = {"video_ann": video_ann_json}
+        return video_ann_json
+
+
     def _inference_project_id(self, api: Api, state: dict, inference_request: InferenceRequest):
         """Inference project images.
         If "output_project_id" in state, upload images and annotations to the output project.
@@ -2955,6 +3120,83 @@ class Inference:
         inference_request.add_results(results)
         inference_request.done(len(results))
 
+    def upload_predictions_to_video(
+        self,
+        predictions: List[Prediction],
+        api: Api,
+        video_info: VideoInfo,
+        track_id: str,
+        context: Dict,
+        progress_cb=None,
+        inference_request: InferenceRequest = None,
+    ):
+        key_id_map = KeyIdMap()
+        project_meta = context.get("project_meta", None)
+        if project_meta is None:
+            project_meta = ProjectMeta.from_json(api.project.get_meta(video_info.project_id))
+            context["project_meta"] = project_meta
+        meta_changed = False
+        for prediction in predictions:
+            project_meta, ann, meta_changed_ = update_meta_and_ann(
+                project_meta, prediction.annotation, None
+            )
+            prediction.annotation = ann
+            meta_changed = meta_changed or meta_changed_
+        if meta_changed:
+            project_meta = api.project.update_meta(video_info.project_id, project_meta)
+            context["project_meta"] = project_meta
+
+        figure_data_by_object_id = defaultdict(list)
+
+        tracks_to_object_ids = context.setdefault("tracks_to_object_ids", {})
+        new_tracks: Dict[int, VideoObject] = {}
+        for prediction in predictions:
+            annotation = prediction.annotation
+            tracks = annotation.custom_data
+            for track, label in zip(tracks, annotation.labels):
+                if track not in tracks_to_object_ids and track not in new_tracks:
+                    video_object = VideoObject(obj_class=label.obj_class)
+                    new_tracks[track] = video_object
+        if new_tracks:
+            tracks, video_objects = zip(*new_tracks.items())
+            added_object_ids = api.video.object.append_bulk(
+                video_info.id, VideoObjectCollection(video_objects), key_id_map=key_id_map
+            )
+            for track, object_id in zip(tracks, added_object_ids):
+                tracks_to_object_ids[track] = object_id
+        for prediction in predictions:
+            annotation = prediction.annotation
+            tracks = annotation.custom_data
+            for track, label in zip(tracks, annotation.labels):
+                object_id = tracks_to_object_ids[track]
+                figure_data_by_object_id[object_id].append(
+                    {
+                        ApiField.OBJECT_ID: object_id,
+                        ApiField.GEOMETRY_TYPE: label.geometry.geometry_name(),
+                        ApiField.GEOMETRY: label.geometry.to_json(),
+                        ApiField.META: {ApiField.FRAME: prediction.frame_index},
+                        ApiField.TRACK_ID: track_id,
+                    }
+                )
+
+        for object_id, figures_data in figure_data_by_object_id.items():
+            figures_keys = [uuid.uuid4() for _ in figures_data]
+            api.video.figure._append_bulk(
+                entity_id=video_info.id,
+                figures_json=figures_data,
+                figures_keys=figures_keys,
+                key_id_map=key_id_map,
+            )
+            logger.debug(f"Added {len(figures_data)} geometries to object #{object_id}")
+        if progress_cb:
+            progress_cb(len(predictions))
+        if inference_request is not None:
+            results = self._format_output(predictions)
+            for result in results:
+                result["annotation"] = None
+                result["data"] = None
+            inference_request.add_results(results)
+
     def serve(self):
         if not self._use_gui and not self._is_cli_deploy:
             Progress("Deploying model ...", 1)
@@ -3352,6 +3594,22 @@ class Inference:
                 "inference_request_uuid": inference_request.uuid,
             }
 
+        @server.post("/tracking_by_detection")
+        def tracking_by_detection(response: Response, request: Request):
+            state = request.state.state
+            context = request.state.context
+            state.update(context)
+            if state.get("tracker") is None:
+                state["tracker"] = "botsort"
+
+            logger.debug("Received a request to 'tracking_by_detection'", extra={"state": state})
+            self.validate_inference_state(state)
+            api = self.api_from_request(request)
+            inference_request, future = self.inference_requests_manager.schedule_task(
+                self._tracking_by_detection, api, state
+            )
+            return {"message": "Track task started."}
+
         @server.post("/inference_project_id_async")
         def inference_project_id_async(response: Response, request: Request):
             state = request.state.state
@@ -3415,10 +3673,7 @@ class Inference:
             data = {**inference_request.to_json(), **log_extra}
             if inference_request.stage != InferenceRequest.Stage.INFERENCE:
                 data["progress"] = {"current": 0, "total": 1}
-            logger.debug(
-                f"Sending inference progress with uuid:",
-                extra=data,
-            )
+            logger.debug(f"Sending inference progress with uuid:", extra=data)
             return data
 
         @server.post(f"/pop_inference_results")
@@ -4411,6 +4666,7 @@ def _filter_duplicated_predictions_from_ann_cpu(
 
     return pred_ann.clone(labels=new_labels)
 
+
 def _filter_duplicated_predictions_from_ann(
     gt_ann: Annotation, pred_ann: Annotation, iou_threshold: float
 ) -> Annotation:
@@ -4644,7 +4900,7 @@ def get_gpu_count():
         gpu_count = len(re.findall(r"GPU \d+:", nvidia_smi_output))
         return gpu_count
     except (subprocess.CalledProcessError, FileNotFoundError) as exc:
-        logger.warn("Calling nvidia-smi caused a error: {exc}. Assume there is no any GPU.")
+        logger.warning("Calling nvidia-smi caused a error: {exc}. Assume there is no any GPU.")
         return 0
 
 
@@ -5111,7 +5367,8 @@ def get_value_for_keys(data: dict, keys: List, ignore_none: bool = False):
             return data[key]
     return None
 
-def torch_load_safe(checkpoint_path: str, device:str = "cpu"):
+
+def torch_load_safe(checkpoint_path: str, device: str = "cpu"):
     import torch  # pylint: disable=import-error
 
     # TODO: handle torch.load(weights_only=True) - change in torch 2.6.0

supervisely/nn/inference/inference_request.py

@@ -14,13 +14,6 @@ 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:
     class Stage:
         PREPARING = "Preparing model for inference..."
@@ -59,7 +52,7 @@ class InferenceRequest:
         self._created_at = time.monotonic()
         self._updated_at = self._created_at
         self._finished = False
-        
+
         self.tracker = None
 
         self.global_progress = None
@@ -252,7 +245,8 @@ class InferenceRequest:
             status_data.pop(key, None)
         status_data.update(self.get_usage())
         return status_data
-    
+
+
 class GlobalProgress:
     def __init__(self):
         self.progress = Progress(message="Ready", total_cnt=1)

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

@@ -2,6 +2,9 @@ import threading
 from typing import Any, Dict, List
 
 from supervisely.api.api import Api
+from supervisely.api.dataset_api import DatasetInfo
+from supervisely.api.project_api import ProjectInfo
+from supervisely.api.video.video_api import VideoInfo
 from supervisely.app.widgets import (
     Button,
     Card,
@@ -202,6 +205,53 @@ class InputSelector:
 
             self.select_video.add_rows(rows)
 
+    def select_project(self, project_id: int, project_info: ProjectInfo = None):
+        if project_info is None:
+            project_info = self.api.project.get_info_by_id(project_id)
+        if project_info.type == ProjectType.IMAGES.value:
+            self.select_dataset_for_images.set_project_id(project_id)
+            self.select_dataset_for_images.select_all()
+            self.radio.set_value(ProjectType.IMAGES.value)
+        elif project_info.type == ProjectType.VIDEOS.value:
+            self.select_dataset_for_video.set_project_id(project_id)
+            self.select_dataset_for_video.select_all()
+            self._refresh_video_table()
+            self.select_video.select_rows(list(range(len(self.select_video._rows_total))))
+            self.radio.set_value(ProjectType.VIDEOS.value)
+        else:
+            raise ValueError(f"Project of type {project_info.type} is not supported.")
+
+    def select_datasets(self, dataset_ids: List[int], dataset_infos: List[DatasetInfo] = None):
+        if dataset_infos is None:
+            dataset_infos = [self.api.dataset.get_info_by_id(ds_id) for ds_id in dataset_ids]
+        project_ids = set(ds.project_id for ds in dataset_infos)
+        if len(project_ids) > 1:
+            raise ValueError("Cannot select datasets from different projects")
+        project_id = project_ids.pop()
+        project_info = self.api.project.get_info_by_id(project_id)
+        if project_info.type == ProjectType.IMAGES.value:
+            self.select_dataset_for_images.set_project_id(project_id)
+            self.select_dataset_for_images.set_dataset_ids(dataset_ids)
+            self.radio.set_value(ProjectType.IMAGES.value)
+        elif project_info.type == ProjectType.VIDEOS.value:
+            self.select_dataset_for_video.set_project_id(project_id)
+            self.select_dataset_for_video.set_dataset_ids(dataset_ids)
+            self._refresh_video_table()
+            self.select_video.select_rows(list(range(self.select_video._rows_total)))
+            self.radio.set_value(ProjectType.VIDEOS.value)
+        else:
+            raise ValueError(f"Project of type {project_info.type} is not supported.")
+
+    def select_videos(self, video_ids: List[int], video_infos: List[VideoInfo] = None):
+        if video_infos is None:
+            video_infos = self.api.video.get_info_by_id_batch(video_ids)
+        project_id = video_infos[0].project_id
+        self.select_dataset_for_video.set_project_id(project_id)
+        self.select_dataset_for_video.select_all()
+        self._refresh_video_table()
+        self.select_video.select_row_by_value("id", video_ids)
+        self.radio.set_value(ProjectType.VIDEOS.value)
+
     def disable(self):
         for widget in self.widgets_to_disable:
             widget.disable()
@@ -249,37 +299,13 @@ class InputSelector:
             video_infos = self.api.video.get_info_by_id_batch(video_ids)
             if not video_infos:
                 raise ValueError(f"Videos with video ids {video_ids} are not found")
-            project_id = video_infos[0].project_id
-            self.select_dataset_for_video.set_project_id(project_id)
-            self.select_dataset_for_video.select_all()
-            self.select_video.select_row_by_value("id", data["video_ids"])
-            self.radio.set_value(ProjectType.VIDEOS.value)
+            self.select_videos(video_ids, video_infos)
         elif "dataset_ids" in data:
             dataset_ids = data["dataset_ids"]
-            if len(dataset_ids) == 0:
-                raise ValueError("Dataset ids cannot be empty")
-            dataset_id = dataset_ids[0]
-            dataset_info = self.api.dataset.get_info_by_id(dataset_id)
-            project_info = self.api.project.get_info_by_id(dataset_info.project_id)
-            if project_info.type == ProjectType.VIDEOS:
-                self.select_dataset_for_video.set_project_id(project_info.id)
-                self.select_dataset_for_video.set_dataset_ids(dataset_ids)
-                self.radio.set_value(ProjectType.VIDEOS.value)
-            else:
-                self.select_dataset_for_images.set_project_id(project_info.id)
-                self.select_dataset_for_images.set_dataset_ids(dataset_ids)
-                self.radio.set_value(ProjectType.IMAGES.value)
+            self.select_datasets(dataset_ids)
         elif "project_id" in data:
             project_id = data["project_id"]
-            project_info = self.api.project.get_info_by_id(project_id)
-            if project_info.type == ProjectType.VIDEOS:
-                self.select_dataset_for_video.set_project_id(project_id)
-                self.select_dataset_for_video.select_all()
-                self.radio.set_value(ProjectType.VIDEOS.value)
-            else:
-                self.select_dataset_for_images.set_project_id(project_id)
-                self.select_dataset_for_images.select_all()
-                self.radio.set_value(ProjectType.IMAGES.value)
+            self.select_project(project_id)
 
     def get_project_id(self) -> int:
         if self.radio.get_value() == ProjectType.IMAGES.value:

supervisely/nn/inference/session.py

@@ -441,46 +441,52 @@ class SessionJSON:
         prev_current = 0
         if preparing_cb:
             # wait for inference status
-            resp = self._get_preparing_progress()
-            awaiting_preparing_progress = 0
-            break_flag = False
-            while resp.get("status") is None:
-                time.sleep(1)
-                awaiting_preparing_progress += 1
-                if awaiting_preparing_progress > 30:
-                    break_flag = True
+            try:
                 resp = self._get_preparing_progress()
-            if break_flag:
-                logger.warning(
-                    "Unable to get preparing progress. Continue without prepaing progress status."
-                )
-            if not break_flag:
-                if resp["status"] == "download_info":
+                for i in range(30):
+                    logger.info(
+                        f"Waiting for preparing progress... {30 - i} seconds left until timeout"
+                    )
+                    resp = self._get_preparing_progress()
+                    if resp.get("status") is not None:
+                        break
+                    time.sleep(1)
+                if not resp.get("status"):
+                    raise RuntimeError("Preparing progress status is not available.")
+
+                if resp.get("status") == "download_info":
+                    logger.info("Downloading infos...")
                     progress_widget = preparing_cb(
                         message="Downloading infos", total=resp["total"], unit="it"
                     )
-                while resp["status"] == "download_info":
-                    current = resp["current"]
-                    # pylint: disable=possibly-used-before-assignment
-                    progress_widget.update(current - prev_current)
-                    prev_current = current
-                    resp = self._get_preparing_progress()
-
-                if resp["status"] == "download_project":
+                    while resp["status"] == "download_info":
+                        current = resp["current"]
+                        # pylint: disable=possibly-used-before-assignment
+                        progress_widget.update(current - prev_current)
+                        prev_current = current
+                        resp = self._get_preparing_progress()
+
+                if resp.get("status") == "download_project":
+                    logger.info("Downloading project...")
                     progress_widget = preparing_cb(message="Download project", total=resp["total"])
-                while resp["status"] == "download_project":
-                    current = resp["current"]
-                    progress_widget.update(current - prev_current)
-                    prev_current = current
-                    resp = self._get_preparing_progress()
-
-                if resp["status"] == "warmup":
+                    while resp.get("status") == "download_project":
+                        current = resp["current"]
+                        progress_widget.update(current - prev_current)
+                        prev_current = current
+                        resp = self._get_preparing_progress()
+
+                if resp.get("status") == "warmup":
+                    logger.info("Running warmup...")
                     progress_widget = preparing_cb(message="Running warmup", total=resp["total"])
-                while resp["status"] == "warmup":
-                    current = resp["current"]
-                    progress_widget.update(current - prev_current)
-                    prev_current = current
-                    resp = self._get_preparing_progress()
+                    while resp.get("status") == "warmup":
+                        current = resp["current"]
+                        progress_widget.update(current - prev_current)
+                        prev_current = current
+                        resp = self._get_preparing_progress()
+            except Exception as ex:
+                logger.warning(
+                    f"An error occurred while getting preparing progress: {ex}. Continue without preparing progress status."
+                )
 
         logger.info("Inference has started:", extra={"response": resp})
         resp, has_started = self._wait_for_async_inference_start()
@@ -537,7 +543,9 @@ class SessionJSON:
         t0 = time.time()
         while not has_started and not timeout_exceeded:
             resp = self._get_inference_progress()
-            has_started = bool(resp.get("result")) or resp["progress"]["total"] != 1
+            pending_results = resp.get("pending_results", None)
+            has_results = bool(pending_results)
+            has_started = bool(resp.get("result")) or resp["progress"]["total"] != 1 or has_results
             if not has_started:
                 time.sleep(delay)
             timeout_exceeded = timeout and time.time() - t0 > timeout