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

supervisely/api/task_api.py

@@ -10,6 +10,7 @@ from pathlib import Path
 # docs
 from typing import Any, Callable, Dict, List, Literal, NamedTuple, Optional, Union
 
+import requests
 from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
 from tqdm import tqdm
 
@@ -307,56 +308,6 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
             f"Waiting time exceeded: total waiting time {wait_attempts * effective_wait_timeout} seconds, i.e. {wait_attempts} attempts for {effective_wait_timeout} seconds each"
         )
 
-    def upload_dtl_archive(
-        self,
-        task_id: int,
-        archive_path: str,
-        progress_cb: Optional[Union[tqdm, Callable]] = None,
-    ):
-        """upload_dtl_archive"""
-        encoder = MultipartEncoder(
-            {
-                "id": str(task_id).encode("utf-8"),
-                "name": get_file_name(archive_path),
-                "archive": (
-                    os.path.basename(archive_path),
-                    open(archive_path, "rb"),
-                    "application/x-tar",
-                ),
-            }
-        )
-
-        def callback(monitor_instance):
-            read_mb = monitor_instance.bytes_read / 1024.0 / 1024.0
-            if progress_cb is not None:
-                progress_cb(read_mb)
-
-        monitor = MultipartEncoderMonitor(encoder, callback)
-        self._api.post("tasks.upload.dtl_archive", monitor)
-
-    def _deploy_model(
-        self,
-        agent_id,
-        model_id,
-        plugin_id=None,
-        version=None,
-        restart_policy=RestartPolicy.NEVER,
-        settings=None,
-    ):
-        """_deploy_model"""
-        response = self._api.post(
-            "tasks.run.deploy",
-            {
-                ApiField.AGENT_ID: agent_id,
-                ApiField.MODEL_ID: model_id,
-                ApiField.RESTART_POLICY: restart_policy.value,
-                ApiField.SETTINGS: settings or {"gpu_device": 0},
-                ApiField.PLUGIN_ID: plugin_id,
-                ApiField.VERSION: version,
-            },
-        )
-        return response.json()[ApiField.TASK_ID]
-
     def get_context(self, id: int) -> Dict:
         """
         Get context information by task ID.
@@ -397,113 +348,6 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         """_convert_json_info"""
         return info
 
-    def run_dtl(self, workspace_id: int, dtl_graph: Dict, agent_id: Optional[int] = None):
-        """run_dtl"""
-        response = self._api.post(
-            "tasks.run.dtl",
-            {
-                ApiField.WORKSPACE_ID: workspace_id,
-                ApiField.CONFIG: dtl_graph,
-                "advanced": {ApiField.AGENT_ID: agent_id},
-            },
-        )
-        return response.json()[ApiField.TASK_ID]
-
-    def _run_plugin_task(
-        self,
-        task_type,
-        agent_id,
-        plugin_id,
-        version,
-        config,
-        input_projects,
-        input_models,
-        result_name,
-    ):
-        """_run_plugin_task"""
-        response = self._api.post(
-            "tasks.run.plugin",
-            {
-                "taskType": task_type,
-                ApiField.AGENT_ID: agent_id,
-                ApiField.PLUGIN_ID: plugin_id,
-                ApiField.VERSION: version,
-                ApiField.CONFIG: config,
-                "projects": input_projects,
-                "models": input_models,
-                ApiField.NAME: result_name,
-            },
-        )
-        return response.json()[ApiField.TASK_ID]
-
-    def run_train(
-        self,
-        agent_id: int,
-        input_project_id: int,
-        input_model_id: int,
-        result_nn_name: str,
-        train_config: Optional[Dict] = None,
-    ):
-        """run_train"""
-        model_info = self._api.model.get_info_by_id(input_model_id)
-        return self._run_plugin_task(
-            task_type=TaskApi.PluginTaskType.TRAIN.value,
-            agent_id=agent_id,
-            plugin_id=model_info.plugin_id,
-            version=None,
-            input_projects=[input_project_id],
-            input_models=[input_model_id],
-            result_name=result_nn_name,
-            config={} if train_config is None else train_config,
-        )
-
-    def run_inference(
-        self,
-        agent_id: int,
-        input_project_id: int,
-        input_model_id: int,
-        result_project_name: str,
-        inference_config: Optional[Dict] = None,
-    ):
-        """run_inference"""
-        model_info = self._api.model.get_info_by_id(input_model_id)
-        return self._run_plugin_task(
-            task_type=TaskApi.PluginTaskType.INFERENCE.value,
-            agent_id=agent_id,
-            plugin_id=model_info.plugin_id,
-            version=None,
-            input_projects=[input_project_id],
-            input_models=[input_model_id],
-            result_name=result_project_name,
-            config={} if inference_config is None else inference_config,
-        )
-
-    def get_training_metrics(self, task_id: int):
-        """get_training_metrics"""
-        response = self._get_response_by_id(
-            id=task_id, method="tasks.train-metrics", id_field=ApiField.TASK_ID
-        )
-        return response.json() if (response is not None) else None
-
-    def deploy_model(self, agent_id: int, model_id: int) -> int:
-        """deploy_model"""
-        task_ids = self._api.model.get_deploy_tasks(model_id)
-        if len(task_ids) == 0:
-            task_id = self._deploy_model(agent_id, model_id)
-        else:
-            task_id = task_ids[0]
-        self.wait(task_id, self.Status.DEPLOYED)
-        return task_id
-
-    def deploy_model_async(self, agent_id: int, model_id: int) -> int:
-        """deploy_model_async"""
-        task_ids = self._api.model.get_deploy_tasks(model_id)
-        if len(task_ids) == 0:
-            task_id = self._deploy_model(agent_id, model_id)
-        else:
-            task_id = task_ids[0]
-        return task_id
-
     def start(
         self,
         agent_id,
@@ -628,36 +472,6 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         response = self._api.post("tasks.stop", {ApiField.ID: id})
         return self.Status(response.json()[ApiField.STATUS])
 
-    def get_import_files_list(self, id: int) -> Union[Dict, None]:
-        """get_import_files_list"""
-        response = self._api.post("tasks.import.files_list", {ApiField.ID: id})
-        return response.json() if (response is not None) else None
-
-    def download_import_file(self, id, file_path, save_path):
-        """download_import_file"""
-        response = self._api.post(
-            "tasks.import.download_file",
-            {ApiField.ID: id, ApiField.FILENAME: file_path},
-            stream=True,
-        )
-
-        ensure_base_path(save_path)
-        with open(save_path, "wb") as fd:
-            for chunk in response.iter_content(chunk_size=1024 * 1024):
-                fd.write(chunk)
-
-    def create_task_detached(self, workspace_id: int, task_type: Optional[str] = None):
-        """create_task_detached"""
-        response = self._api.post(
-            "tasks.run.python",
-            {
-                ApiField.WORKSPACE_ID: workspace_id,
-                ApiField.SCRIPT: "xxx",
-                ApiField.ADVANCED: {ApiField.IGNORE_AGENT: True},
-            },
-        )
-        return response.json()[ApiField.TASK_ID]
-
     def submit_logs(self, logs) -> None:
         """submit_logs"""
         response = self._api.post("tasks.logs.add", {ApiField.LOGS: logs})
@@ -791,28 +605,6 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         result = self.get_fields(task_id, [field])
         return result[field]
 
-    def _validate_checkpoints_support(self, task_id):
-        """_validate_checkpoints_support"""
-        # pylint: disable=too-few-format-args
-        info = self.get_info_by_id(task_id)
-        if info["type"] != str(TaskApi.PluginTaskType.TRAIN):
-            raise RuntimeError(
-                "Task (id={!r}) has type {!r}. "
-                "Checkpoints are available only for tasks of type {!r}".format()
-            )
-
-    def list_checkpoints(self, task_id: int):
-        """list_checkpoints"""
-        self._validate_checkpoints_support(task_id)
-        resp = self._api.post("tasks.checkpoints.list", {ApiField.ID: task_id})
-        return resp.json()
-
-    def delete_unused_checkpoints(self, task_id: int) -> Dict:
-        """delete_unused_checkpoints"""
-        self._validate_checkpoints_support(task_id)
-        resp = self._api.post("tasks.checkpoints.clear", {ApiField.ID: task_id})
-        return resp.json()
-
     def _set_output(self):
         """_set_output"""
         pass
@@ -1229,267 +1021,34 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         )
         return resp.json()
 
-    def deploy_model_from_api(self, task_id, deploy_params):
-        self.send_request(
-            task_id,
-            "deploy_from_api",
-            data={"deploy_params": deploy_params},
-            raise_error=True,
-        )
-
-    def deploy_model_app(
-        self,
-        module_id: int,
-        workspace_id: int,
-        agent_id: Optional[int] = None,
-        description: Optional[str] = "application description",
-        params: Dict[str, Any] = None,
-        log_level: Optional[Literal["info", "debug", "warning", "error"]] = "info",
-        users_ids: Optional[List[int]] = None,
-        app_version: Optional[str] = "",
-        is_branch: Optional[bool] = False,
-        task_name: Optional[str] = "pythonSpawned",
-        restart_policy: Optional[Literal["never", "on_error"]] = "never",
-        proxy_keep_url: Optional[bool] = False,
-        redirect_requests: Optional[Dict[str, int]] = {},
-        limit_by_workspace: bool = False,
-        deploy_params: Dict[str, Any] = None,
-        timeout: int = 100,
-    ):
-        if deploy_params is None:
-            deploy_params = {}
-        task_info = self.start(
-            agent_id=agent_id,
-            workspace_id=workspace_id,
-            module_id=module_id,
-            description=description,
-            params=params,
-            log_level=log_level,
-            users_ids=users_ids,
-            app_version=app_version,
-            is_branch=is_branch,
-            task_name=task_name,
-            restart_policy=restart_policy,
-            proxy_keep_url=proxy_keep_url,
-            redirect_requests=redirect_requests,
-            limit_by_workspace=limit_by_workspace,
-        )
-
-        attempt_delay_sec = 10
-        attempts = (timeout + attempt_delay_sec) // attempt_delay_sec
-        ready = self._api.app.wait_until_ready_for_api_calls(
-            task_info["id"], attempts, attempt_delay_sec
-        )
-        if not ready:
-            raise TimeoutError(
-                f"Task {task_info['id']} is not ready for API calls after {timeout} seconds."
-            )
-        logger.info("Deploying model from API")
-        self.deploy_model_from_api(task_info["id"], deploy_params=deploy_params)
-        return task_info
-
-    def deploy_custom_model(
-        self,
-        workspace_id: int,
-        artifacts_dir: str,
-        checkpoint_name: str = None,
-        agent_id: int = None,
-        device: str = "cuda",
-    ) -> int:
+    def is_running(self, task_id: int) -> bool:
         """
-        Deploy a custom model based on the artifacts directory.
+        Check if the task is running.
 
-        :param workspace_id: Workspace ID in Supervisely.
-        :type workspace_id: int
-        :param artifacts_dir: Path to the artifacts directory.
-        :type artifacts_dir: str
-        :param checkpoint_name: Checkpoint name (with extension) to deploy.
-        :type checkpoint_name: Optional[str]
-        :param agent_id: Agent ID in Supervisely.
-        :type agent_id: Optional[int]
-        :param device: Device string (default is "cuda").
-        :type device: str
-        :raises ValueError: if validations fail.
+        :param task_id: Task ID in Supervisely.
+        :type task_id: int
+        :return: True if the task is running, False otherwise.
+        :rtype: bool
         """
-        from dataclasses import asdict
-
-        from supervisely.nn.artifacts import (
-            RITM,
-            RTDETR,
-            Detectron2,
-            MMClassification,
-            MMDetection,
-            MMDetection3,
-            MMSegmentation,
-            UNet,
-            YOLOv5,
-            YOLOv5v2,
-            YOLOv8,
-        )
-        from supervisely.nn.experiments import get_experiment_info_by_artifacts_dir
-        from supervisely.nn.utils import ModelSource, RuntimeType
-
-        if not isinstance(workspace_id, int) or workspace_id <= 0:
-            raise ValueError(f"workspace_id must be a positive integer. Received: {workspace_id}")
-        if not isinstance(artifacts_dir, str) or not artifacts_dir.strip():
-            raise ValueError("artifacts_dir must be a non-empty string.")
-
-        workspace_info = self._api.workspace.get_info_by_id(workspace_id)
-        if workspace_info is None:
-            raise ValueError(f"Workspace with ID '{workspace_id}' not found.")
-
-        team_id = workspace_info.team_id
-        logger.debug(
-            f"Starting model deployment. Team: {team_id}, Workspace: {workspace_id}, Artifacts Dir: '{artifacts_dir}'"
-        )
-
-        # Train V1 logic (if artifacts_dir does not start with '/experiments')
-        if not artifacts_dir.startswith("/experiments"):
-            logger.debug("Deploying model from Train V1 artifacts")
-            frameworks = {
-                "/detectron2": Detectron2,
-                "/mmclassification": MMClassification,
-                "/mmdetection": MMDetection,
-                "/mmdetection-3": MMDetection3,
-                "/mmsegmentation": MMSegmentation,
-                "/RITM_training": RITM,
-                "/RT-DETR": RTDETR,
-                "/unet": UNet,
-                "/yolov5_train": YOLOv5,
-                "/yolov5_2.0_train": YOLOv5v2,
-                "/yolov8_train": YOLOv8,
-            }
+        try:
+            self.send_request(task_id, "is_running", {}, retries=1, raise_error=True)
+        except requests.exceptions.HTTPError as e:
+            return False
+        return True
 
-            framework_cls = next(
-                (cls for prefix, cls in frameworks.items() if artifacts_dir.startswith(prefix)),
-                None,
-            )
-            if not framework_cls:
-                raise ValueError(f"Unsupported framework for artifacts_dir: '{artifacts_dir}'")
-
-            framework = framework_cls(team_id)
-            if framework_cls is RITM or framework_cls is YOLOv5:
-                raise ValueError(
-                    f"{framework.framework_name} framework is not supported for deployment"
-                )
-
-            logger.debug(f"Detected framework: '{framework.framework_name}'")
-
-            module_id = self._api.app.get_ecosystem_module_id(framework.serve_slug)
-            serve_app_name = framework.serve_app_name
-            logger.debug(f"Module ID fetched:' {module_id}'. App name: '{serve_app_name}'")
-
-            train_info = framework.get_info_by_artifacts_dir(artifacts_dir.rstrip("/"))
-            if not hasattr(train_info, "checkpoints") or not train_info.checkpoints:
-                raise ValueError("No checkpoints found in train info.")
-
-            checkpoint = None
-            if checkpoint_name is not None:
-                for cp in train_info.checkpoints:
-                    if cp.name == checkpoint_name:
-                        checkpoint = cp
-                        break
-                if checkpoint is None:
-                    raise ValueError(f"Checkpoint '{checkpoint_name}' not found in train info.")
-            else:
-                logger.debug("Checkpoint name not provided. Using the last checkpoint.")
-                checkpoint = train_info.checkpoints[-1]
-
-            checkpoint_name = checkpoint.name
-            deploy_params = {
-                "device": device,
-                "model_source": ModelSource.CUSTOM,
-                "task_type": train_info.task_type,
-                "checkpoint_name": checkpoint_name,
-                "checkpoint_url": checkpoint.path,
-            }
-
-            if getattr(train_info, "config_path", None) is not None:
-                deploy_params["config_url"] = train_info.config_path
-
-            if framework.require_runtime:
-                deploy_params["runtime"] = RuntimeType.PYTORCH
-
-        else:  # Train V2 logic (when artifacts_dir starts with '/experiments')
-            logger.debug("Deploying model from Train V2 artifacts")
-
-            def get_framework_from_artifacts_dir(artifacts_dir: str) -> str:
-                clean_path = artifacts_dir.rstrip("/")
-                parts = clean_path.split("/")
-                if not parts or "_" not in parts[-1]:
-                    raise ValueError(f"Invalid artifacts_dir format: '{artifacts_dir}'")
-                return parts[-1].split("_", 1)[1]
-
-            # TODO: temporary solution, need to add Serve App Name into config.json
-            framework_name = get_framework_from_artifacts_dir(artifacts_dir)
-            logger.debug(f"Detected framework: {framework_name}")
-
-            modules = self._api.app.get_list_all_pages(
-                method="ecosystem.list",
-                data={"filter": [], "search": framework_name, "categories": ["serve"]},
-                convert_json_info_cb=lambda x: x,
-            )
-            if not modules:
-                raise ValueError(f"No serve apps found for framework: '{framework_name}'")
-
-            module = modules[0]
-            module_id = module["id"]
-            serve_app_name = module["name"]
-            logger.debug(f"Serving app delected: '{serve_app_name}'. Module ID: '{module_id}'")
+    def is_ready(self, task_id: int) -> bool:
+        """
+        Check if the task is ready.
 
-            experiment_info = get_experiment_info_by_artifacts_dir(
-                self._api, team_id, artifacts_dir
+        :param task_id: Task ID in Supervisely.
+        :type task_id: int
+        :return: True if the task is ready, False otherwise.
+        :rtype: bool
+        """
+        try:
+            return (
+                self.send_request(task_id, "is_ready", {}, retries=1, raise_error=True)["status"]
+                == "ready"
             )
-            if not experiment_info:
-                raise ValueError(
-                    f"Failed to retrieve experiment info for artifacts_dir: '{artifacts_dir}'"
-                )
-
-            if len(experiment_info.checkpoints) == 0:
-                raise ValueError(f"No checkpoints found in: '{artifacts_dir}'.")
-
-            checkpoint = None
-            if checkpoint_name is not None:
-                for checkpoint_path in experiment_info.checkpoints:
-                    if get_file_name_with_ext(checkpoint_path) == checkpoint_name:
-                        checkpoint = get_file_name_with_ext(checkpoint_path)
-                        break
-                if checkpoint is None:
-                    raise ValueError(
-                        f"Provided checkpoint '{checkpoint_name}' not found. Using the best checkpoint."
-                    )
-            else:
-                logger.debug("Checkpoint name not provided. Using the best checkpoint.")
-                checkpoint = experiment_info.best_checkpoint
-
-            checkpoint_name = checkpoint
-            deploy_params = {
-                "device": device,
-                "model_source": ModelSource.CUSTOM,
-                "model_files": {
-                    "checkpoint": f"{experiment_info.artifacts_dir}checkpoints/{checkpoint_name}"
-                },
-                "model_info": asdict(experiment_info),
-                "runtime": RuntimeType.PYTORCH,
-            }
-            # TODO: add support for **kwargs
-
-            config = experiment_info.model_files.get("config")
-            if config is not None:
-                deploy_params["model_files"]["config"] = f"{experiment_info.artifacts_dir}{config}"
-                logger.debug(f"Config file added: {experiment_info.artifacts_dir}{config}")
-
-        logger.info(
-            f"{serve_app_name} app deployment started. Checkpoint: '{checkpoint_name}'. Deploy params: '{deploy_params}'"
-        )
-        task_info = self.deploy_model_app(
-            module_id,
-            workspace_id,
-            agent_id,
-            description=f"Deployed via deploy_custom_model",
-            task_name=f"{serve_app_name} ({checkpoint_name})",
-            deploy_params=deploy_params,
-        )
-        if task_info is None:
-            raise RuntimeError(f"Failed to run '{serve_app_name}'.")
-        return task_info["id"]
+        except requests.exceptions.HTTPError as e:
+            return False

supervisely/app/fastapi/subapp.py

@@ -1018,6 +1018,7 @@ class Application(metaclass=Singleton):
 
         @server.get("/readyz")
         @server.get("/is_ready")
+        @server.post("/is_ready")
         async def is_ready(response: Response, request: Request):
             is_ready = True
             if self._ready_check_function is not None:

supervisely/nn/__init__.py

@@ -2,6 +2,7 @@ import supervisely.nn.artifacts as artifacts
 import supervisely.nn.benchmark as benchmark
 import supervisely.nn.inference as inference
 from supervisely.nn.artifacts.artifacts import BaseTrainArtifacts, TrainInfo
+from supervisely.nn.experiments import ExperimentInfo, get_experiment_infos
 from supervisely.nn.prediction_dto import (
     Prediction,
     PredictionAlphaMask,
@@ -14,4 +15,4 @@ from supervisely.nn.prediction_dto import (
 )
 from supervisely.nn.task_type import TaskType
 from supervisely.nn.utils import ModelSource, RuntimeType
-from supervisely.nn.experiments import ExperimentInfo, get_experiment_infos
+from supervisely.nn.model.model_api import ModelAPI

supervisely/nn/artifacts/artifacts.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import random
 import string
 from abc import abstractmethod
@@ -9,15 +10,14 @@ from json import JSONDecodeError
 from os.path import dirname, join
 from time import time
 from typing import Any, Dict, List, Literal, NamedTuple, Union
-
 import requests
 
 from supervisely import logger
 from supervisely._utils import abs_url, is_development
-from supervisely.api.api import Api, ApiField
 from supervisely.api.file_api import FileInfo
 from supervisely.io.fs import get_file_name_with_ext, silent_remove
 from supervisely.io.json import dump_json_file
+from supervisely.api.api import Api, ApiField
 from supervisely.nn.experiments import ExperimentInfo
 
 
@@ -578,7 +578,7 @@ class BaseTrainArtifacts:
 
     def convert_train_to_experiment_info(
         self, train_info: TrainInfo
-    ) -> Union[ExperimentInfo, None]:
+    ) -> Union['ExperimentInfo', None]:
         try:
             checkpoints = []
             for chk in train_info.checkpoints:
@@ -637,7 +637,7 @@ class BaseTrainArtifacts:
 
     def get_list_experiment_info(
         self, sort: Literal["desc", "asc"] = "desc"
-    ) -> List[ExperimentInfo]:
+    ) -> List['ExperimentInfo']:
         train_infos = self.get_list(sort)
 
         # Sync version
@@ -671,7 +671,7 @@ class BaseTrainArtifacts:
         self,
         artifacts_dir: str,
         return_type: Literal["train_info", "experiment_info"] = "train_info",
-    ) -> Union[TrainInfo, ExperimentInfo, None]:
+    ) -> Union[TrainInfo, 'ExperimentInfo', None]:
         """
         Get training info by artifacts directory.
 

supervisely/nn/benchmark/object_detection/metric_provider.py

@@ -4,6 +4,7 @@ from copy import deepcopy
 import numpy as np
 import pandas as pd
 
+from supervisely._utils import logger
 from supervisely.nn.benchmark.utils.detection import metrics
 
 METRIC_NAMES = {
@@ -106,6 +107,8 @@ class MetricProvider:
 
         # Confidence threshold that will be used in visualizations
         self.conf_threshold = self.custom_conf_threshold or self.f1_optimal_conf
+        if self.conf_threshold is None:
+            raise RuntimeError("Model predicted no TP matches. Cannot calculate metrics.")
 
         # Filter by optimal confidence threshold
         if self.conf_threshold is not None:

supervisely/nn/experiments.py

@@ -1,8 +1,8 @@
 from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass, fields
+from dataclasses import MISSING, dataclass, fields
 from json import JSONDecodeError
 from os.path import dirname, join
-from typing import List, Optional, Union
+from typing import Dict, List, Optional, Union
 
 import requests
 
@@ -59,6 +59,26 @@ class ExperimentInfo:
     logs: Optional[dict] = None
     """Dictionary with link and type of logger"""
 
+    def __init__(self, **kwargs):
+        required_fieds = {
+            field.name for field in fields(self.__class__) if field.default is MISSING
+        }
+        missing_fields = required_fieds - set(kwargs.keys())
+        if missing_fields:
+            raise ValueError(
+                f"ExperimentInfo missing required arguments: '{', '.join(missing_fields)}'"
+            )
+        field_names = set(f.name for f in fields(self.__class__))
+        kwargs = {k: v for k, v in kwargs.items() if k in field_names}
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def to_json(self) -> Dict:
+        data = {}
+        for field in fields(self.__class__):
+            value = getattr(self, field.name)
+            data[field.name] = value
+
 
 def get_experiment_infos(api: Api, team_id: int, framework_name: str) -> List[ExperimentInfo]:
     """
@@ -128,7 +148,8 @@ def get_experiment_infos(api: Api, team_id: int, framework_name: str) -> List[Ex
                     f"Missing required fields: {missing_required_fields} for '{experiment_path}'. Skipping."
                 )
                 return None
-            return ExperimentInfo(**response_json)
+            field_names = {field.name for field in fields(ExperimentInfo)}
+            return ExperimentInfo(**{k: v for k, v in response_json.items() if k in field_names})
         except requests.exceptions.RequestException as e:
             logger.debug(f"Request failed for '{experiment_path}': {e}")
         except JSONDecodeError as e:
@@ -166,9 +187,11 @@ def _fetch_experiment_data(api, team_id: int, experiment_path: str) -> Union[Exp
         response.raise_for_status()
         response_json = response.json()
         required_fields = {
-            field.name for field in fields(ExperimentInfo) if field.default is not None
+            field.name for field in fields(ExperimentInfo) if field.default is MISSING
+        }
+        optional_fields = {
+            field.name for field in fields(ExperimentInfo) if field.default is not MISSING
         }
-        optional_fields = {field.name for field in fields(ExperimentInfo) if field.default is None}
 
         missing_optional_fields = optional_fields - response_json.keys()
         if missing_optional_fields: