supervisely 6.73.410__py3-none-any.whl → 6.73.470__py3-none-any.whl

supervisely/geometry/polyline_3d.py

@@ -0,0 +1,110 @@
+from supervisely.geometry.geometry import Geometry
+from supervisely.geometry.constants import LABELER_LOGIN, UPDATED_AT, CREATED_AT, ID, CLASS_ID
+from supervisely.geometry.cuboid_3d import Vector3d
+from typing import List, Union
+
+
+class Polyline3D(Geometry):
+    """
+    Polyline3D geometry
+
+    :param points: List of 3D point coordinates which define the polyline in 3D space.
+    :type points: List[List[int, int, int]]
+    :param sly_id: Polyline ID in Supervisely server.
+    :type sly_id: int, optional
+    :param class_id: ID of :class:`ObjClass<supervisely.annotation.obj_class.ObjClass>` to which Polyline belongs.
+    :type class_id: int, optional
+    :param labeler_login: Login of the user who created Polyline.
+    :type labeler_login: str, optional
+    :param updated_at: Date and Time when Polyline was modified last. Date Format: Year:Month:Day:Hour:Minute:Seconds. Example: '2021-01-22T19:37:50.158Z'.
+    :type updated_at: str, optional
+    :param created_at: Date and Time when Polyline was created. Date Format is the same as in "updated_at" parameter.
+    :type created_at: str, optional
+
+    :Usage example:
+
+     .. code-block:: python
+
+        import supervisely as sly
+
+        points = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+        figure = sly.Polyline(points)
+    """
+
+    @staticmethod
+    def geometry_name():
+        return "polyline_3d"
+
+    def __init__(
+        self,
+        points: Union[List[float], List[Vector3d]],
+        sly_id=None,
+        class_id=None,
+        labeler_login=None,
+        updated_at=None,
+        created_at=None,
+    ):
+        if not isinstance(points[0], Vector3d):
+            points = [Vector3d(point[0], point[1], point[2]) for point in points]
+        super().__init__(
+            sly_id=sly_id,
+            class_id=class_id,
+            labeler_login=labeler_login,
+            updated_at=updated_at,
+            created_at=created_at,
+        )
+
+        self._points = points
+
+    @property
+    def points(self):
+        return self._points
+
+    def to_json(self):
+        points = [[point.x, point.y, point.z] for point in self._points]
+        res = {"points": points}
+        self._add_creation_info(res)
+        return res
+
+    @classmethod
+    def from_json(cls, data):
+        """
+        Convert a json dict to Polyline3D.
+
+        :param data: Polyline3D in json format as a dict.
+        :type data: dict
+        :return: Polyline3D object
+        :rtype: :class:`Polyline3D<Polyline3D>`
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            figure_json = {
+                "points": {
+                    [
+                        [1, 2, 3],
+                        [4, 5, 6],
+                        [7, 8, 9]
+                    ],
+                }
+            }
+            figure = sly.Polyline3D.from_json(figure_json)
+        """
+        if not data.get("points"):
+            raise ValueError("Data dict must contain 'points' field!")
+        points = data["points"]
+        labeler_login = data.get(LABELER_LOGIN, None)
+        updated_at = data.get(UPDATED_AT, None)
+        created_at = data.get(CREATED_AT, None)
+        sly_id = data.get(ID, None)
+        class_id = data.get(CLASS_ID, None)
+        return cls(
+            points,
+            sly_id=sly_id,
+            class_id=class_id,
+            labeler_login=labeler_login,
+            updated_at=updated_at,
+            created_at=created_at,
+        )

supervisely/io/env.py

@@ -1,9 +1,14 @@
 # coding: utf-8
+import json
 import os
+from contextvars import ContextVar, Token
 from typing import Callable, List, Literal, Optional, Union
 
 RAISE_IF_NOT_FOUND = True
-
+_MULTIUSER_USER_CTX: ContextVar[Optional[Union[int, str]]] = ContextVar(
+    "supervisely_multiuser_app_user_id",
+    default=None,
+)
 
 def flag_from_env(s: str) -> bool:
     """Returns True if passed string is a flag, False otherwise.
@@ -686,3 +691,158 @@ def configure_minimum_instance_version() -> None:
     latest_version = get_latest_instance_version_from_json()
     if latest_version:
         os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = latest_version
+
+def app_categories(raise_not_found: Optional[bool] = False) -> list:
+    """Returns a list of app categories from environment variable using following keys:
+        - APP_CATEGORIES
+    :param raise_not_found: if True, raises KeyError if app category is not found in environment variables
+    :type raise_not_found: Optional[bool]
+    :return: app categories
+    :rtype: list
+    """
+    return _parse_from_env(
+        name="app_category",
+        keys=["APP_CATEGORIES"],
+        postprocess_fn=lambda x: json.loads(x),
+        default=[],
+        raise_not_found=raise_not_found,
+    )
+
+
+def upload_count(raise_not_found: Optional[bool] = False) -> dict:
+    """Returns a dictionary of upload counts from environment variable using following
+        - UPLOAD_COUNT
+    :param raise_not_found: if True, raises KeyError if upload count is not found in environment variables
+    :type raise_not_found: Optional[bool]
+    :return: upload count
+    :rtype: dict
+    """
+    return _parse_from_env(
+        name="upload_count",
+        keys=["UPLOAD_COUNT"],
+        postprocess_fn=lambda x: json.loads(x),
+        default={},
+        raise_not_found=raise_not_found,
+    )
+
+
+def uploaded_ids(raise_not_found: Optional[bool] = False) -> dict:
+    """Returns a dictionary with dataset IDs as keys and lists of uploaded IDs as values from environment variable using following
+        - UPLOADED_IDS
+    :param raise_not_found: if True, raises KeyError if uploaded IDs is not found in environment variables
+    :type raise_not_found: Optional[bool]
+    :return: uploaded IDs
+    :rtype: dict
+    """
+    return _parse_from_env(
+        name="uploaded_ids",
+        keys=["UPLOADED_IDS"],
+        postprocess_fn=lambda x: json.loads(x),
+        default={},
+        raise_not_found=raise_not_found,
+    )
+
+
+def increment_upload_count(dataset_id: int, count: int = 1) -> None:
+    """Increments the upload count for the given dataset id by the specified count.
+
+    :param dataset_id: The dataset id to increment the upload count for.
+    :type dataset_id: int
+    :param count: The amount to increment the upload count by. Defaults to 1.
+    :type count: int
+    """
+    upload_info = upload_count()
+    upload_info[str(dataset_id)] = upload_info.get(str(dataset_id), 0) + count
+    os.environ["UPLOAD_COUNT"] = json.dumps(upload_info)
+
+
+def add_uploaded_ids_to_env(dataset_id: int, ids: List[int]) -> None:
+    """Adds the list of uploaded IDs to the environment variable for the given dataset ID.
+
+    :param dataset_id: The dataset ID to associate the uploaded IDs with.
+    :type dataset_id: int
+    :param ids: The list of uploaded IDs to add.
+    :type ids: List[int]
+    """
+    uploaded = uploaded_ids()
+    if str(dataset_id) not in uploaded:
+        uploaded[str(dataset_id)] = []
+    existing_ids = set(uploaded[str(dataset_id)])
+    if set(ids).intersection(existing_ids):
+        for _id in ids:
+            if _id not in existing_ids:
+                uploaded[str(dataset_id)].append(_id)
+    else:
+        uploaded[str(dataset_id)].extend(ids)
+    os.environ["UPLOADED_IDS"] = json.dumps(uploaded)
+
+
+def is_multiuser_mode_enabled() -> bool:
+    """Returns multiuser app mode flag from environment variable using following keys:
+        - SUPERVISELY_MULTIUSER_APP_MODE
+    :return: multiuser app mode flag
+    :rtype: bool
+    """
+    return _parse_from_env(
+        name="is_multiuser_mode_enabled",
+        keys=["SUPERVISELY_MULTIUSER_APP_MODE"],
+        default=False,
+        raise_not_found=False,
+        postprocess_fn=flag_from_env,
+    )
+
+
+def enable_multiuser_app_mode() -> None:
+    """
+    Enables multiuser app mode by setting the environment variable.
+    This function can be used to activate multiuser mode in the application allowing
+    separation of user DataJson/StateJson.
+    """
+    os.environ["SUPERVISELY_MULTIUSER_APP_MODE"] = "true"
+
+
+def disable_multiuser_app_mode() -> None:
+    """Disables multiuser app mode by removing the environment variable."""
+    os.environ.pop("SUPERVISELY_MULTIUSER_APP_MODE", None)
+
+
+def set_user_for_multiuser_app(user_id: Optional[Union[int, str]]) -> Token:
+    """
+    Sets the user ID for multiuser app mode by setting the environment variable.
+    This function should be used in multiuser mode to separate user DataJson/StateJson.
+
+    :param user_id: The user ID (or session key) to set for the current request.
+    :type user_id: int | str
+    :return: A context token that can be used to reset the user ID later.
+    :rtype: Token
+    :raises RuntimeError: If multiuser app mode is not enabled.
+    """
+    if not is_multiuser_mode_enabled():
+        raise RuntimeError("Multiuser app mode is not enabled. Cannot set user ID.")
+    return _MULTIUSER_USER_CTX.set(user_id)
+
+
+def reset_user_for_multiuser_app(token: Token) -> None:
+    """
+    Resets the user ID for multiuser app mode using the provided context token.
+
+    :param token: Context token obtained from `set_user_for_multiuser_app`.
+    :type token: Token
+    """
+    if not is_multiuser_mode_enabled():
+        return
+    _MULTIUSER_USER_CTX.reset(token)
+
+
+def user_from_multiuser_app() -> Optional[Union[int, str]]:
+    """
+    Retrieves the user ID for multiuser app mode from the environment variable.
+
+    :return: The user ID if set, otherwise None.
+    :rtype: Optional[Union[int, str]]
+    """
+    if not is_multiuser_mode_enabled():
+        return None
+    user_id = _MULTIUSER_USER_CTX.get(None)
+    if user_id is not None:
+        return user_id

supervisely/nn/artifacts/__init__.py

@@ -1,6 +1,6 @@
 from supervisely.nn.artifacts.detectron2 import Detectron2
 from supervisely.nn.artifacts.hrda import HRDA
-from supervisely.nn.artifacts.mmclassification import MMClassification
+from supervisely.nn.artifacts.mmclassification import MMClassification, MMPretrain
 from supervisely.nn.artifacts.mmdetection import MMDetection, MMDetection3
 from supervisely.nn.artifacts.mmsegmentation import MMSegmentation
 from supervisely.nn.artifacts.ritm import RITM

supervisely/nn/artifacts/artifacts.py

@@ -68,6 +68,7 @@ class BaseTrainArtifacts:
         self._pattern: str = None
         self._available_task_types: List[str] = []
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     @property
     def team_id(self) -> int:
@@ -209,6 +210,13 @@ class BaseTrainArtifacts:
         """
         return self._require_runtime
 
+    @property
+    def has_benchmark_evaluation(self):
+        """
+        Whether the framework has integrated benchmark evaluation.
+        """
+        return self._has_benchmark_evaluation
+
     def is_valid_artifacts_path(self, path):
         """
         Check if the provided path is valid and follows specified session path pattern.
@@ -610,9 +618,9 @@ class BaseTrainArtifacts:
             date_time = parsed_datetime.strftime("%Y-%m-%d %H:%M:%S")
 
             experiment_info_data = {
-                "experiment_name": f"Unknown {self.framework_name} experiment",
+                "experiment_name": f"{self.framework_name} experiment",
                 "framework_name": self.framework_name,
-                "model_name": f"Unknown {self.framework_name} model",
+                "model_name": f"{self.framework_name} model",
                 "task_type": train_info.task_type,
                 "project_id": project_id,
                 "task_id": train_info.task_id,

supervisely/nn/artifacts/detectron2.py

@@ -25,6 +25,7 @@ class Detectron2(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/detectron2/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["instance segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/artifacts/hrda.py

@@ -20,6 +20,7 @@ class HRDA(BaseTrainArtifacts):
         # self._config_file = "config.py"
         # self._available_task_types: List[str] = ["semantic segmentation"]
         # self._require_runtime = False
+        # self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         raise NotImplementedError

supervisely/nn/artifacts/mmclassification.py

@@ -21,6 +21,7 @@ class MMClassification(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/mmclassification/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["classification"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")
@@ -44,3 +45,22 @@ class MMClassification(BaseTrainArtifacts):
 
     def get_config_path(self, artifacts_folder: str) -> str:
         return None
+
+
+class MMPretrain(MMClassification):
+    def __init__(self, team_id: int):
+        super().__init__(team_id)
+
+        self._app_name = "Train MMPretrain"
+        self._slug = "supervisely-ecosystem/mmpretrain/supervisely/train"
+        self._serve_app_name = "Serve MMPretrain"
+        self._serve_slug = "supervisely-ecosystem/mmpretrain/supervisely/serve"
+        self._framework_name = "MMPretrain"
+        self._framework_folder = "/mmclassification-v2"
+        self._weights_folder = "checkpoints"
+        self._task_type = "classification"
+        self._weights_ext = ".pth"
+        self._pattern = re_compile(r"^/mmclassification-v2/\d+_[^/]+/?$")
+        self._available_task_types: List[str] = ["classification"]
+        self._require_runtime = False
+        self._has_benchmark_evaluation = False

supervisely/nn/artifacts/mmdetection.py

@@ -26,6 +26,7 @@ class MMDetection(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/mmdetection/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["object detection", "instance segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")
@@ -63,8 +64,8 @@ class MMDetection3(BaseTrainArtifacts):
         super().__init__(team_id)
 
         self._app_name = "Train MMDetection 3.0"
-        self._slug = "Serve MMDetection 3.0"
-        self._serve_app_name = "supervisely-ecosystem/train-mmdetection-v3"
+        self._slug = "supervisely-ecosystem/train-mmdetection-v3"
+        self._serve_app_name = "Serve MMDetection 3.0"
         self._serve_slug = "supervisely-ecosystem/serve-mmdetection-v3"
         self._framework_name = "MMDetection 3.0"
         self._framework_folder = "/mmdetection-3"
@@ -75,7 +76,8 @@ class MMDetection3(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/mmdetection-3/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["object detection", "instance segmentation"]
         self._require_runtime = False
-        
+        self._has_benchmark_evaluation = True
+
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")
         if len(parts) < 3:

supervisely/nn/artifacts/mmsegmentation.py

@@ -22,6 +22,7 @@ class MMSegmentation(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/mmsegmentation/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["instance segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = True
 
     def get_task_id(self, artifacts_folder: str) -> str:
         return artifacts_folder.split("/")[2].split("_")[0]

supervisely/nn/artifacts/ritm.py

@@ -22,6 +22,7 @@ class RITM(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/RITM_training/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["interactive segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/artifacts/rtdetr.py

@@ -22,6 +22,7 @@ class RTDETR(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/RT-DETR/[^/]+/\d+/?$")
         self._available_task_types: List[str] = ["object detection"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = True
 
     def get_task_id(self, artifacts_folder: str) -> str:
         return artifacts_folder.split("/")[-1]

supervisely/nn/artifacts/unet.py

@@ -22,6 +22,7 @@ class UNet(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/unet/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["semantic segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = True
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/artifacts/utils.py

@@ -4,6 +4,7 @@ from supervisely.nn.artifacts import (
     YOLOv5v2,
     YOLOv8,
     MMClassification,
+    MMPretrain,
     MMSegmentation,
     MMDetection,
     MMDetection3,
@@ -19,6 +20,7 @@ class FrameworkName:
     YOLOV5V2 = "YOLOv5 2.0"
     YOLOV8 = "YOLOv8+"
     MMCLASSIFICATION = "MMClassification"
+    MMPRETRAIN = "MMPretrain"
     MMSEGMENTATION = "MMSegmentation"
     MMDETECTION = "MMDetection"
     MMDETECTION3 = "MMDetection 3.0"
@@ -34,6 +36,7 @@ class FrameworkMapper:
         FrameworkName.YOLOV5V2: YOLOv5v2,
         FrameworkName.YOLOV8: YOLOv8,
         FrameworkName.MMCLASSIFICATION: MMClassification,
+        FrameworkName.MMPRETRAIN: MMPretrain,
         FrameworkName.MMSEGMENTATION: MMSegmentation,
         FrameworkName.MMDETECTION: MMDetection,
         FrameworkName.MMDETECTION3: MMDetection3,

supervisely/nn/artifacts/yolov5.py

@@ -22,6 +22,7 @@ class YOLOv5(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/yolov5_train/[^/]+/\d+/?$")
         self._available_task_types: List[str] = ["object detection"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         return artifacts_folder.split("/")[-1]
@@ -55,3 +56,4 @@ class YOLOv5v2(YOLOv5):
         self._config_file = None
         self._pattern = re_compile(r"^/yolov5_2.0_train/[^/]+/\d+/?$")
         self._available_task_types: List[str] = ["object detection"]
+        self._has_benchmark_evaluation = False

supervisely/nn/artifacts/yolov8.py

@@ -28,6 +28,7 @@ class YOLOv8(BaseTrainArtifacts):
             "pose estimation",
         ]
         self._require_runtime = True
+        self._has_benchmark_evaluation = True
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/benchmark/semantic_segmentation/metric_provider.py

@@ -70,24 +70,24 @@ class MetricProvider:
 
     def json_metrics(self):
         return {
-            "mIoU": self.eval_data.loc["mean"]["IoU"] * 100,
-            "mE_boundary_oU": self.eval_data.loc["mean"]["E_boundary_oU"] * 100,
-            "mFP_boundary_oU": self.eval_data.loc["mean"]["FP_boundary_oU"] * 100,
-            "mFN_boundary_oU": self.eval_data.loc["mean"]["FN_boundary_oU"] * 100,
-            "mE_boundary_oU_renormed": self.eval_data.loc["mean"]["E_boundary_oU_renormed"] * 100,
-            "mE_extent_oU": self.eval_data.loc["mean"]["E_extent_oU"] * 100,
-            "mFP_extent_oU": self.eval_data.loc["mean"]["FP_extent_oU"] * 100,
-            "mFN_extent_oU": self.eval_data.loc["mean"]["FN_extent_oU"] * 100,
-            "mE_extent_oU_renormed": self.eval_data.loc["mean"]["E_extent_oU_renormed"] * 100,
-            "mE_segment_oU": self.eval_data.loc["mean"]["E_segment_oU"] * 100,
-            "mFP_segment_oU": self.eval_data.loc["mean"]["FP_segment_oU"] * 100,
-            "mFN_segment_oU": self.eval_data.loc["mean"]["FN_segment_oU"] * 100,
-            "mE_segment_oU_renormed": self.eval_data.loc["mean"]["E_segment_oU_renormed"] * 100,
-            "mPrecision": self.eval_data.loc["mean"]["precision"] * 100,
-            "mRecall": self.eval_data.loc["mean"]["recall"] * 100,
-            "mF1_score": self.eval_data.loc["mean"]["F1_score"] * 100,
-            "PixelAcc": self.pixel_accuracy * 100,
-            "mBoundaryIoU": self.eval_data.loc["mean"]["boundary_IoU"] * 100,
+            "mIoU": self.eval_data.loc["mean"]["IoU"],
+            "mE_boundary_oU": self.eval_data.loc["mean"]["E_boundary_oU"],
+            "mFP_boundary_oU": self.eval_data.loc["mean"]["FP_boundary_oU"],
+            "mFN_boundary_oU": self.eval_data.loc["mean"]["FN_boundary_oU"],
+            "mE_boundary_oU_renormed": self.eval_data.loc["mean"]["E_boundary_oU_renormed"],
+            "mE_extent_oU": self.eval_data.loc["mean"]["E_extent_oU"],
+            "mFP_extent_oU": self.eval_data.loc["mean"]["FP_extent_oU"],
+            "mFN_extent_oU": self.eval_data.loc["mean"]["FN_extent_oU"],
+            "mE_extent_oU_renormed": self.eval_data.loc["mean"]["E_extent_oU_renormed"],
+            "mE_segment_oU": self.eval_data.loc["mean"]["E_segment_oU"],
+            "mFP_segment_oU": self.eval_data.loc["mean"]["FP_segment_oU"],
+            "mFN_segment_oU": self.eval_data.loc["mean"]["FN_segment_oU"],
+            "mE_segment_oU_renormed": self.eval_data.loc["mean"]["E_segment_oU_renormed"],
+            "mPrecision": self.eval_data.loc["mean"]["precision"],
+            "mRecall": self.eval_data.loc["mean"]["recall"],
+            "mF1_score": self.eval_data.loc["mean"]["F1_score"],
+            "PixelAcc": self.pixel_accuracy,
+            "mBoundaryIoU": self.eval_data.loc["mean"]["boundary_IoU"],
         }
 
     def metric_table(self):

supervisely/nn/experiments.py

@@ -54,6 +54,8 @@ class ExperimentInfo:
     """Number of images in the validation set"""
     datetime: Optional[str] = None
     """Date and time when the experiment was started"""
+    experiment_report_id: Optional[int] = None
+    """ID of the experiment report"""
     evaluation_report_id: Optional[int] = None
     """ID of the model benchmark evaluation report"""
     evaluation_report_link: Optional[str] = None
@@ -62,6 +64,12 @@ class ExperimentInfo:
     """Evaluation metrics"""
     logs: Optional[dict] = None
     """Dictionary with link and type of logger"""
+    train_collection_id: Optional[int] = None
+    """ID of the collection with train images"""
+    val_collection_id: Optional[int] = None
+    """ID of the collection with validation images"""
+    project_version: Optional[int] = None
+    """Version of the project"""
 
     def __init__(self, **kwargs):
         required_fieds = {
@@ -82,6 +90,7 @@ class ExperimentInfo:
         for field in fields(self.__class__):
             value = getattr(self, field.name)
             data[field.name] = value
+        return data
 
 
 def get_experiment_infos(api: Api, team_id: int, framework_name: str) -> List[ExperimentInfo]:

supervisely/nn/inference/cache.py

@@ -771,7 +771,7 @@ class InferenceImageCache:
     def _download_many(
         self,
         indexes: List[Union[int, str]],
-        name_cunstructor: Callable[[int], str],
+        name_constructor: Callable[[int], str],
         load_generator: Callable[
             [List[int]],
             Generator[Tuple[Union[int, str], np.ndarray], None, None],
@@ -785,24 +785,42 @@ class InferenceImageCache:
         all_frames = [None for _ in range(len(indexes))]
 
         def get_one_image(item):
-            pos, index = item
+            pos, hash_or_id = 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))
+                try:
+                    frame = self.get_frame_from_cache(video_id, hash_or_id)
+                except Exception as e:
+                    logger.error(
+                        f"Error retrieving frame from cache: {repr(e)}. Frame will be re-downloaded",
+                        exc_info=True,
+                    )
+                    ids_to_load.append(hash_or_id)
+                    return pos, None
+                return pos, frame
+            try:
+                image = self._cache.get_image(name_constructor(hash_or_id))
+            except Exception as e:
+                logger.error(
+                    f"Error retrieving image from cache: {repr(e)}. Image will be re-downloaded",
+                    exc_info=True,
+                )
+                ids_to_load.append(hash_or_id)
+                return pos, None
+            return pos, image
 
         position = 0
         batch_size = 4
         for batch in batched(indexes, batch_size):
-            indexes_to_load = []
+            ids_to_load = []
             items = []
             for hash_or_id in batch:
-                name = name_cunstructor(hash_or_id)
+                name = name_constructor(hash_or_id)
                 self._wait_if_in_queue(name, logger)
-
+                pos_by_name[name] = position
                 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
+                    ids_to_load.append(hash_or_id)
+
                 elif return_images is True:
                     items.append((position, hash_or_id))
                 position += 1
@@ -810,14 +828,16 @@ class InferenceImageCache:
             if len(items) > 0:
                 with ThreadPoolExecutor(min(64, len(items))) as executor:
                     for pos, image in executor.map(get_one_image, items):
+                        if image is None:
+                            continue
                         all_frames[pos] = image
                         if progress_cb is not None:
                             progress_cb()
 
             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)
+            if len(ids_to_load) > 0:
+                for id_or_hash, image in load_generator(ids_to_load):
+                    name = name_constructor(id_or_hash)
                     self._add_to_cache(name, image)
 
                     if return_images:
@@ -828,13 +848,13 @@ class InferenceImageCache:
             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)
+            if ids_to_load:
+                ids_to_load = list(ids_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},
+                    f"Images/Frames added to cache: {ids_to_load} in {download_time:.2f} sec",
+                    extra={"indexes": ids_to_load, "download_time": download_time},
                 )
-            found = set(batch).difference(indexes_to_load)
+            found = set(batch).difference(ids_to_load)
             if found:
                 logger.debug(f"Images/Frames found in cache: {list(found)}")