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

supervisely/io/env.py

@@ -1,10 +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.
@@ -771,3 +775,74 @@ def add_uploaded_ids_to_env(dataset_id: int, ids: List[int]) -> None:
     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/io/fs.py

@@ -929,6 +929,27 @@ def get_file_hash_chunked(path: str, chunk_size: Optional[int] = 1024 * 1024) ->
     return base64.b64encode(digest).decode("utf-8")
 
 
+async def get_file_hash_chunked_async(path: str, chunk_size: Optional[int] = 1024 * 1024) -> str:
+    """
+    Asynchronously get hash from target file by reading it in chunks.
+
+    :param path: Target file path.
+    :type path: str
+    :param chunk_size: Number of bytes to read per iteration. Default is 1 MB.
+    :type chunk_size: int, optional
+    :returns: File hash as a base64 encoded string.
+    :rtype: str
+    """
+    hash_sha256 = hashlib.sha256()
+    async with aiofiles.open(path, "rb") as file:
+        while True:
+            chunk = await file.read(chunk_size)
+            if not chunk:
+                break
+            hash_sha256.update(chunk)
+    return base64.b64encode(hash_sha256.digest()).decode("utf-8")
+
+
 def tree(dir_path: str) -> str:
     """
     Get tree for target directory.

supervisely/nn/benchmark/base_evaluator.py

@@ -1,13 +1,19 @@
 from __future__ import annotations
 
+import json
 import os
 import pickle
-from typing import Dict, List, Optional, Union
+import zipfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
 
+import numpy as np
+import pandas as pd
 import yaml
 
 from supervisely.app.widgets import SlyTqdm
-from supervisely.io.fs import get_file_name_with_ext
+from supervisely.io.fs import get_file_name_with_ext, silent_remove
+from supervisely.io.json import dump_json_file, load_json_file
 from supervisely.task.progress import tqdm_sly
 
 
@@ -17,8 +23,8 @@ class BaseEvalResult:
     def __init__(self, directory: Optional[str] = None):
         self.directory = directory
         self.inference_info: Dict = {}
-        self.speedtest_info: Dict = None
-        self.eval_data: Dict = None
+        self.speedtest_info: Optional[Dict] = None
+        self.eval_data: Optional[Dict] = None
         self.mp = None
 
         if self.directory is not None:
@@ -44,19 +50,19 @@ class BaseEvalResult:
         )
 
     @property
-    def short_name(self) -> str:
+    def short_name(self) -> Union[str, None]:
         if not self.name:
-            return
+            return None
         if len(self.name) > 20:
             return self.name[:9] + "..." + self.name[-7:]
         return self.name
 
     @property
-    def gt_project_id(self) -> int:
+    def gt_project_id(self) -> Optional[int]:
         return self.inference_info.get("gt_project_id")
 
     @property
-    def gt_dataset_ids(self) -> List[int]:
+    def gt_dataset_ids(self) -> Optional[List[int]]:
         return self.inference_info.get("gt_dataset_ids", None)
 
     @property
@@ -112,9 +118,49 @@ class BaseEvalResult:
             name = self.inference_info.get("checkpoint_name", "")
         return name
 
+    def _load_eval_data_archive(self, path: Path, pd_index_col=False) -> Dict:
+        """Load eval_data from archive"""
+        with zipfile.ZipFile(path, mode="r") as zf:
+            with zf.open("eval_data.json") as json_f:
+                data = json.load(json_f)
+            return self._process_value_from_archive(data, zf, pd_index_col)
+
+    def _process_value_from_archive(self, value, zf: zipfile.ZipFile, pd_index_col: bool = False):
+        """Recursively process values from archive, handling nested dicts and lists."""
+        if isinstance(value, str) and value.endswith(".npy"):
+            with zf.open(value) as arr_f:
+                return np.load(arr_f)
+        elif isinstance(value, str) and value.endswith(".csv"):
+            with zf.open(value) as df_f:
+                if pd_index_col:
+                    return pd.read_csv(df_f, sep="\t", index_col=0)
+                return pd.read_csv(df_f, sep="\t")
+        elif isinstance(value, dict):
+            res = {}
+            for k, v in value.items():
+                k = int(k) if isinstance(k, str) and k.isdigit() else k
+                k = float(k) if isinstance(k, str) and self._is_float(k) else k
+                res[k] = self._process_value_from_archive(v, zf, pd_index_col)
+            return res
+        elif isinstance(value, list):
+            return [self._process_value_from_archive(item, zf, pd_index_col) for item in value]
+        elif isinstance(value, str) and value.isdigit():
+            return int(value)
+        else:
+            return value
+
+    def _is_float(self, s: str) -> bool:
+        if not s or not isinstance(s, str):
+            return False
+        try:
+            float(s)
+            return "." in s or "e" in s.lower()
+        except (ValueError, AttributeError):
+            return False
+
 
 class BaseEvaluator:
-    EVALUATION_PARAMS_YAML_PATH: str = None
+    EVALUATION_PARAMS_YAML_PATH: Optional[str] = None
     eval_result_cls = BaseEvalResult
 
     def __init__(
@@ -127,13 +173,14 @@ class BaseEvaluator:
         classes_whitelist: Optional[List[str]] = None,
         evaluation_params: Optional[dict] = None,
     ):
+        self.eval_data: Optional[Dict] = None
         self.gt_project_path = gt_project_path
         self.pred_project_path = pred_project_path
         self.result_dir = result_dir
         self.total_items = items_count
         self.pbar = progress or tqdm_sly
         os.makedirs(result_dir, exist_ok=True)
-        self.classes_whitelist = classes_whitelist
+        self.classes_whitelist = classes_whitelist or []
 
         if evaluation_params is None:
             evaluation_params = self._get_default_evaluation_params()
@@ -160,11 +207,57 @@ class BaseEvaluator:
         if cls.EVALUATION_PARAMS_YAML_PATH is None:
             return {}
         else:
-            return yaml.safe_load(cls.load_yaml_evaluation_params())
+            params = cls.load_yaml_evaluation_params()
+            if params is None:
+                return {}
+            return yaml.safe_load(params)
 
     def _dump_pickle(self, data, file_path):
         with open(file_path, "wb") as f:
             pickle.dump(data, f)
 
+    def _process_value_for_archive(self, value: Any, key_prefix: str, zf: zipfile.ZipFile) -> Any:
+        """Recursively process values for archiving, handling nested dicts and lists."""
+        if isinstance(value, np.ndarray):
+            filename = f"{key_prefix}.npy" if key_prefix else "array.npy"
+            filepath = os.path.join(self.result_dir, filename)
+            np.save(filepath, value)
+            zf.write(filepath, arcname=filename)
+            os.remove(filepath)
+            return filename
+        elif isinstance(value, pd.DataFrame):
+            filename = f"{key_prefix}.csv" if key_prefix else "dataframe.csv"
+            filepath = os.path.join(self.result_dir, filename)
+            value.to_csv(filepath, sep="\t")
+            zf.write(filepath, arcname=filename)
+            os.remove(filepath)
+            return filename
+        elif isinstance(value, dict):
+            return {
+                k: self._process_value_for_archive(v, f"{key_prefix}.{k}" if key_prefix else k, zf)
+                for k, v in value.items()
+            }
+        elif isinstance(value, list):
+            return [
+                self._process_value_for_archive(item, f"{key_prefix}[{i}]", zf)
+                for i, item in enumerate(value)
+            ]
+        elif isinstance(value, (np.integer, np.floating)):
+            return value.item()
+        elif isinstance(value, np.bool_):
+            return bool(value)
+        elif isinstance(value, str) and value.isdigit():
+            return int(value)
+        else:
+            return value
+
+    def _dump_eval_results_archive(self):
+        with zipfile.ZipFile(os.path.join(self.result_dir, "eval_data.zip"), mode="w") as zf:
+            data = self._process_value_for_archive(self.eval_data, "", zf)
+            filepath = os.path.join(self.result_dir, "eval_data.json")
+            dump_json_file(data, filepath, indent=4)
+            zf.write(filepath, arcname="eval_data.json")
+            silent_remove(filepath)
+
     def get_eval_result(self) -> BaseEvalResult:
         return self.eval_result_cls(self.result_dir)

supervisely/nn/benchmark/instance_segmentation/evaluator.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import os
 from pathlib import Path
 
 from supervisely.io.json import dump_json_file
@@ -57,16 +56,10 @@ class InstanceSegmentationEvaluator(ObjectDetectionEvaluator):
         self._dump_eval_results()
 
     def _dump_eval_results(self):
+        self._dump_eval_results_archive()
         _, _, eval_data_path = self._get_eval_paths()
         self._dump_pickle(self.eval_data, eval_data_path)
 
-    def _get_eval_paths(self):
-        base_dir = self.result_dir
-        cocoGt_path = os.path.join(base_dir, "cocoGt.json")
-        cocoDt_path = os.path.join(base_dir, "cocoDt.json")
-        eval_data_path = os.path.join(base_dir, "eval_data.pkl")
-        return cocoGt_path, cocoDt_path, eval_data_path
-
     def _dump_datasets(self):
         cocoGt_path, cocoDt_path, _ = self._get_eval_paths()
         dump_json_file(self.cocoGt_json, cocoGt_path, indent=None)

supervisely/nn/benchmark/object_detection/evaluator.py

@@ -15,6 +15,7 @@ from supervisely.nn.benchmark.utils import (
     sly2coco,
 )
 from supervisely.nn.benchmark.visualization.vis_click_data import ClickData, IdMapper
+from supervisely.sly_logger import logger
 
 
 class ObjectDetectionEvalResult(BaseEvalResult):
@@ -30,10 +31,24 @@ class ObjectDetectionEvalResult(BaseEvalResult):
         if self.coco_gt.exists() and self.coco_dt.exists():
             self.coco_gt, self.coco_dt = read_coco_datasets(self.coco_gt, self.coco_dt)
 
-        eval_data_path = Path(path) / "eval_data.pkl"
-        if eval_data_path.exists():
-            with open(Path(path, "eval_data.pkl"), "rb") as f:
-                self.eval_data = pickle.load(f)
+        eval_data_pickle_path = Path(path) / "eval_data.pkl"
+        eval_data_archive_path = Path(path) / "eval_data.zip"
+        if eval_data_pickle_path.exists():
+            try:
+                with open(Path(path, "eval_data.pkl"), "rb") as f:
+                    self.eval_data = pickle.load(f)
+            except Exception as e:
+                logger.warning(f"Failed to load eval_data.pkl: {e}", exc_info=True)
+                self.eval_data = None
+        if self.eval_data is None and eval_data_archive_path.exists():
+            try:
+                self.eval_data = self._load_eval_data_archive(eval_data_archive_path)
+            except Exception as e:
+                logger.warning(f"Failed to load eval_data from archive: {e}", exc_info=True)
+                self.eval_data = None
+
+        if self.eval_data is None:
+            raise ValueError("Failed to load eval_data. Please contact support.")
 
         inference_info_path = Path(path) / "inference_info.json"
         if inference_info_path.exists():
@@ -172,6 +187,7 @@ class ObjectDetectionEvaluator(BaseEvaluator):
         cocoGt_path, cocoDt_path, eval_data_path = self._get_eval_paths()
         dump_json_file(self.cocoGt_json, cocoGt_path, indent=None)
         dump_json_file(self.cocoDt_json, cocoDt_path, indent=None)
+        self._dump_eval_results_archive()
         self._dump_pickle(self.eval_data, eval_data_path)
 
     def _get_eval_paths(self):

supervisely/nn/benchmark/object_detection/vis_metrics/pr_curve.py

@@ -19,16 +19,21 @@ class PRCurve(DetectionVisMetric):
 
     @property
     def md(self) -> MarkdownWidget:
-        text = self.vis_texts.markdown_pr_curve.format(self.vis_texts.definitions.about_pr_tradeoffs)
+        text = self.vis_texts.markdown_pr_curve.format(
+            self.vis_texts.definitions.about_pr_tradeoffs
+        )
         return MarkdownWidget(self.MARKDOWN, "Precision-Recall Curve", text)
 
     @property
     def notification(self) -> NotificationWidget:
         title, _ = self.vis_texts.notification_ap.values()
-        return NotificationWidget(
-            self.NOTIFICATION,
-            title.format(self.eval_result.mp.base_metrics()["mAP"].round(2)),
-        )
+        _map = self.eval_result.mp.base_metrics()["mAP"]
+        if isinstance(_map, float):
+            _map = round(_map, 2)
+        elif isinstance(_map, np.ndarray):
+            _map = float(np.round(_map, 2))
+
+        return NotificationWidget(self.NOTIFICATION, title.format(_map))
 
     @property
     def chart(self) -> ChartWidget:

supervisely/nn/benchmark/semantic_segmentation/evaluator.py

@@ -4,11 +4,10 @@ import os
 import pickle
 import shutil
 from pathlib import Path
-from typing import List
+from typing import List, Optional
 
 import cv2
 import numpy as np
-from tqdm import tqdm
 
 from supervisely.io.json import load_json_file
 from supervisely.nn.benchmark.base_evaluator import BaseEvalResult, BaseEvaluator
@@ -30,10 +29,25 @@ class SemanticSegmentationEvalResult(BaseEvalResult):
     def _read_files(self, path: str) -> None:
         """Read all necessary files from the directory"""
 
-        eval_data_path = Path(path) / "eval_data.pkl"
-        if eval_data_path.exists():
-            with open(Path(path, "eval_data.pkl"), "rb") as f:
-                self.eval_data = pickle.load(f)
+        eval_data_pickle_path = Path(path) / "eval_data.pkl"
+        eval_data_archive_path = Path(path) / "eval_data.zip"
+        if eval_data_pickle_path.exists():
+            try:
+                with open(Path(path, "eval_data.pkl"), "rb") as f:
+                    self.eval_data = pickle.load(f)
+            except Exception as e:
+                logger.warning(f"Failed to load eval_data.pkl: {e}", exc_info=True)
+                self.eval_data = None
+
+        if self.eval_data is None and eval_data_archive_path.exists():
+            try:
+                self.eval_data = self._load_eval_data_archive(eval_data_archive_path, pd_index_col=True)
+            except Exception as e:
+                logger.warning(f"Failed to load eval_data from archive: {e}", exc_info=True)
+                self.eval_data = None
+
+        if self.eval_data is None:
+            raise ValueError("Failed to load eval_data. Please contact support.")
 
         inference_info_path = Path(path) / "inference_info.json"
         if inference_info_path.exists():
@@ -69,12 +83,12 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.bg_cls_name = None
-        self.bg_cls_color = None
+        self.bg_cls_name: Optional[str] = None
+        self.bg_cls_color: Optional[List[int]] = None
 
     def evaluate(self):
         self.bg_cls_name = self._get_bg_class_name()
-        if self.bg_cls_name not in self.classes_whitelist:
+        if self.bg_cls_name not in self.classes_whitelist and self.bg_cls_name is not None:
             self.classes_whitelist.append(self.bg_cls_name)
 
         gt_prep_path, pred_prep_path = self.prepare_segmentation_data()
@@ -94,9 +108,9 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
         self._dump_eval_results()
         logger.info("Evaluation results are saved")
 
-    def _get_palette(self, project_path):
+    def _get_palette(self, project_path) -> List[List[int]]:
         meta_path = Path(project_path) / "meta.json"
-        meta = ProjectMeta.from_json(load_json_file(meta_path))
+        meta = ProjectMeta.from_json(load_json_file(str(meta_path)))
 
         palette = []
         for cls_name in self.classes_whitelist:
@@ -109,8 +123,9 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
         return palette
 
     def _dump_eval_results(self):
+        self._dump_eval_results_archive()
         eval_data_path = self._get_eval_data_path()
-        self._dump_pickle(self.eval_data, eval_data_path)  # TODO: maybe dump JSON?
+        self._dump_pickle(self.eval_data, eval_data_path)
 
     def _get_eval_data_path(self):
         base_dir = self.result_dir
@@ -130,11 +145,14 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
                 continue
 
             palette = self._get_palette(src_dir)
-            bg_cls_idx = self.classes_whitelist.index(self.bg_cls_name)
+            if self.bg_cls_name is not None:
+                bg_cls_idx = self.classes_whitelist.index(self.bg_cls_name)
+            else:
+                raise ValueError("Background class name is not set.")
             try:
                 bg_color = palette[bg_cls_idx]
             except IndexError:
-                bg_color = (0, 0, 0)
+                bg_color = [0, 0, 0]
             output_dir.mkdir(parents=True)
             temp_seg_dir = src_dir + "_temp"
             if not os.path.exists(temp_seg_dir):
@@ -174,14 +192,14 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
 
         return output_dirs
 
-    def _get_bg_class_name(self):
+    def _get_bg_class_name(self) -> Optional[str]:
         possible_names = ["background", "bg", "unlabeled", "neutral", "__bg__"]
         logger.info(f"Searching for background class in projects. Possible names: {possible_names}")
 
         bg_cls_names = []
         for project_path in [self.gt_project_path, self.pred_project_path]:
             meta_path = Path(project_path) / "meta.json"
-            meta = ProjectMeta.from_json(load_json_file(meta_path))
+            meta = ProjectMeta.from_json(load_json_file(str(meta_path)))
 
             for obj_cls in meta.obj_classes:
                 if obj_cls.name in possible_names:

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/confusion_matrix.py

@@ -82,7 +82,7 @@ class ConfusionMatrix(SemanticSegmVisMetric):
                 res["clickData"][key]["imagesIds"] = []
 
                 cmat_key = str(ig) + "_" + str(ip)
-                for name in self.eval_result.mp.cmat_cell_img_names[cmat_key]:
+                for name in self.eval_result.mp.cmat_cell_img_names.get(cmat_key, []):
                     gt_img_id = self.eval_result.images_map[name]
                     pred_img_id = self.eval_result.matched_pair_data[gt_img_id].pred_image_info.id
                     res["clickData"][key]["imagesIds"].append(pred_img_id)

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/frequently_confused.py

@@ -91,7 +91,7 @@ class FrequentlyConfused(SemanticSegmVisMetric):
             res["clickData"][key] = {}
             res["clickData"][key]["imagesIds"] = []
             idx_key = str(gt_idx) + "_" + str(pred_idx)
-            for name in self.eval_result.mp.cmat_cell_img_names[idx_key]:
+            for name in self.eval_result.mp.cmat_cell_img_names.get(idx_key, []):
                 gt_img_id = self.eval_result.images_map[name]
                 pred_img_id = self.eval_result.matched_pair_data[gt_img_id].pred_image_info.id
                 res["clickData"][key]["imagesIds"].append(pred_img_id)

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/overview.py

@@ -22,7 +22,7 @@ class Overview(SemanticSegmVisMetric):
         url = self.eval_result.inference_info.get("checkpoint_url")
         link_text = self.eval_result.inference_info.get("custom_checkpoint_path")
         if link_text is None:
-            link_text = url
+            link_text = url or ""
         link_text = link_text.replace("_", "\_")
 
         model_name = self.eval_result.inference_info.get("model_name") or "Custom"

supervisely/nn/benchmark/visualization/evaluation_result.py

@@ -1,13 +1,16 @@
+import json
 import pickle
+import zipfile
 from pathlib import Path
 from typing import Dict, List, Optional
 
+import numpy as np
 import pandas as pd
 
 from supervisely.annotation.annotation import ProjectMeta
 from supervisely.api.api import Api
-from supervisely.api.module_api import ApiField
 from supervisely.api.dataset_api import DatasetInfo
+from supervisely.api.module_api import ApiField
 from supervisely.api.project_api import ProjectInfo
 from supervisely.app.widgets import SlyTqdm
 from supervisely.io.env import team_id
@@ -197,6 +200,49 @@ class EvalResult:
     #             progress_cb=pbar.update,
     #         )
 
+    def _load_eval_data_archive(self, path: Path, pd_index_col: bool = False) -> Dict:
+        """Load eval_data from archive"""
+        with zipfile.ZipFile(path, mode="r") as zf:
+            with zf.open("eval_data.json") as json_f:
+                data = json.load(json_f)
+            return self._process_value_from_archive(data, zf, pd_index_col=pd_index_col)
+
+    def _process_value_from_archive(self, value, zf: zipfile.ZipFile, pd_index_col: bool = False):
+        """Recursively process values from archive, handling nested dicts and lists."""
+        if isinstance(value, str) and value.endswith(".npy"):
+            with zf.open(value) as arr_f:
+                return np.load(arr_f)
+        elif isinstance(value, str) and value.endswith(".csv"):
+            with zf.open(value) as df_f:
+                if pd_index_col:
+                    return pd.read_csv(df_f, sep="\t", index_col=0)
+                return pd.read_csv(df_f, sep="\t")
+        elif isinstance(value, dict):
+            res = {}
+            for k, v in value.items():
+                k = int(k) if isinstance(k, str) and k.isdigit() else k
+                k = float(k) if isinstance(k, str) and self._is_float(k) else k
+                res[k] = self._process_value_from_archive(v, zf, pd_index_col=pd_index_col)
+            return res
+        elif isinstance(value, list):
+            return [
+                self._process_value_from_archive(item, zf, pd_index_col=pd_index_col)
+                for item in value
+            ]
+        elif isinstance(value, str) and value.isdigit():
+            return int(value)
+        else:
+            return value
+
+    def _is_float(self, s: str) -> bool:
+        if not s or not isinstance(s, str):
+            return False
+        try:
+            float(s)
+            return "." in s or "e" in s.lower()
+        except (ValueError, AttributeError):
+            return False
+
     def _read_eval_data(self):
         from pycocotools.coco import COCO  # pylint: disable=import-error
 
@@ -205,9 +251,25 @@ class EvalResult:
         coco_gt, coco_dt = COCO(gt_path), COCO(dt_path)
         self.coco_gt = coco_gt
         self.coco_dt = coco_dt
-        self.eval_data = pickle.load(
-            open(Path(self.local_dir, "evaluation", "eval_data.pkl"), "rb")
-        )
+        eval_data_pickle_path = Path(self.local_dir, "evaluation", "eval_data.pkl")
+        eval_data_archive_path = Path(self.local_dir, "evaluation", "eval_data.zip")
+        if eval_data_pickle_path.exists():
+            try:
+                with open(eval_data_pickle_path, "rb") as f:
+                    self.eval_data = pickle.load(f)
+            except Exception as e:
+                logger.warning(f"Failed to load eval_data.pkl: {e}", exc_info=True)
+                self.eval_data = None
+        if self.eval_data is None and eval_data_archive_path.exists():
+            try:
+                self.eval_data = self._load_eval_data_archive(eval_data_archive_path)
+            except Exception as e:
+                logger.warning(f"Failed to load eval_data from archive: {e}", exc_info=True)
+                self.eval_data = None
+
+        if self.eval_data is None:
+            raise ValueError("Failed to load eval_data. Please contact support.")
+
         self.inference_info = load_json_file(
             Path(self.local_dir, "evaluation", "inference_info.json")
         )