supervisely 6.73.302__tar.gz → 6.73.303__tar.gz

{supervisely-6.73.302/supervisely.egg-info → supervisely-6.73.303}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.302
+Version: 6.73.303
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.302 → supervisely-6.73.303}/supervisely/api/task_api.py

@@ -5,6 +5,7 @@ import json
 import os
 import time
 from collections import OrderedDict, defaultdict
+from pathlib import Path
 
 # docs
 from typing import Any, Callable, Dict, List, Literal, NamedTuple, Optional, Union
@@ -12,6 +13,7 @@ from typing import Any, Callable, Dict, List, Literal, NamedTuple, Optional, Uni
 from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
 from tqdm import tqdm
 
+from supervisely import logger
 from supervisely._utils import batched, take_with_default
 from supervisely.api.module_api import (
     ApiField,
@@ -20,7 +22,12 @@ from supervisely.api.module_api import (
     WaitingTimeExceeded,
 )
 from supervisely.collection.str_enum import StrEnum
-from supervisely.io.fs import ensure_base_path, get_file_hash, get_file_name
+from supervisely.io.fs import (
+    ensure_base_path,
+    get_file_hash,
+    get_file_name,
+    get_file_name_with_ext,
+)
 
 
 class TaskFinishedWithError(Exception):
@@ -301,7 +308,10 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         )
 
     def upload_dtl_archive(
-        self, task_id: int, archive_path: str, progress_cb: Optional[Union[tqdm, Callable]] = None
+        self,
+        task_id: int,
+        archive_path: str,
+        progress_cb: Optional[Union[tqdm, Callable]] = None,
     ):
         """upload_dtl_archive"""
         encoder = MultipartEncoder(
@@ -822,11 +832,19 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         return resp.json()
 
     def set_output_report(
-        self, task_id: int, file_id: int, file_name: str, description: Optional[str] = "Report"
+        self,
+        task_id: int,
+        file_id: int,
+        file_name: str,
+        description: Optional[str] = "Report",
     ) -> Dict:
         """set_output_report"""
         return self._set_custom_output(
-            task_id, file_id, file_name, description=description, icon="zmdi zmdi-receipt"
+            task_id,
+            file_id,
+            file_name,
+            description=description,
+            icon="zmdi zmdi-receipt",
         )
 
     def _set_custom_output(
@@ -942,7 +960,11 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         )
 
     def update_meta(
-        self, id: int, data: dict, agent_storage_folder: str = None, relative_app_dir: str = None
+        self,
+        id: int,
+        data: dict,
+        agent_storage_folder: str = None,
+        relative_app_dir: str = None,
     ):
         """
         Update given task metadata
@@ -1197,3 +1219,265 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
             "tasks.output.set", {ApiField.TASK_ID: task_id, ApiField.OUTPUT: output}
         )
         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."
+            )
+        self.deploy_model_from_api(task_info["id"], deploy_params=deploy_params)
+        return task_info
+
+    def deploy_custom_model(
+        self,
+        team_id: int,
+        workspace_id: int,
+        artifacts_dir: str,
+        checkpoint_name: str = None,
+        agent_id: int = None,
+        device: str = "cuda",
+    ):
+        """
+        Deploy a custom model based on the artifacts directory.
+
+        :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.
+        """
+        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,
+            }
+
+            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}'")
+
+            experiment_info = get_experiment_info_by_artifacts_dir(
+                self._api, team_id, artifacts_dir
+            )
+            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}'"
+        )
+        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,
+        )

{supervisely-6.73.302 → supervisely-6.73.303}/supervisely/nn/artifacts/artifacts.py

@@ -3,11 +3,12 @@ import string
 from abc import abstractmethod
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import fields
 from datetime import datetime
 from json import JSONDecodeError
 from os.path import dirname, join
 from time import time
-from typing import Any, Dict, List, Literal, NamedTuple
+from typing import Any, Dict, List, Literal, NamedTuple, Union
 
 import requests
 
@@ -55,6 +56,9 @@ class BaseTrainArtifacts:
         self._metadata_file_name: str = "train_info.json"
 
         self._app_name: str = None
+        self._slug = None
+        self._serve_app_name = None
+        self._serve_slug = None
         self._framework_name: str = None
         self._framework_folder: str = None
         self._weights_folder: str = None
@@ -63,6 +67,7 @@ class BaseTrainArtifacts:
         self._config_file: str = None
         self._pattern: str = None
         self._available_task_types: List[str] = []
+        self._require_runtime = False
 
     @property
     def team_id(self) -> int:
@@ -94,6 +99,36 @@ class BaseTrainArtifacts:
         """
         return self._app_name
 
+    @property
+    def slug(self):
+        """
+        Train app slug.
+
+        :return: Train app slug.
+        :rtype: str
+        """
+        return self._slug
+
+    @property
+    def serve_app_name(self):
+        """
+        Serve application name.
+
+        :return: The serve application name.
+        :rtype: str
+        """
+        return self._serve_app_name
+
+    @property
+    def serve_slug(self):
+        """
+        Serve app slug.
+
+        :return: Serve app slug.
+        :rtype: str
+        """
+        return self._serve_slug
+
     @property
     def framework_name(self):
         """
@@ -164,6 +199,16 @@ class BaseTrainArtifacts:
         """
         return self._pattern
 
+    @property
+    def require_runtime(self):
+        """
+        Whether providing runtime is required for the framework.
+
+        :return: True if runtime is required, False otherwise.
+        :rtype: bool
+        """
+        return self._require_runtime
+
     def is_valid_artifacts_path(self, path):
         """
         Check if the provided path is valid and follows specified session path pattern.
@@ -531,68 +576,68 @@ class BaseTrainArtifacts:
         logger.debug(f"Listing time: '{format(end_time - start_time, '.6f')}' sec")
         return train_infos
 
-    def get_list_experiment_info(self, sort: Literal["desc", "asc"] = "desc") -> List[TrainInfo]:
-        def build_experiment_info_from_train_info(
-            api: Api, train_info: TrainInfo
-        ) -> ExperimentInfo:
-
-            try:
-                checkpoints = []
-                for chk in train_info.checkpoints:
-                    if self.weights_folder:
-                        checkpoints.append(join(self.weights_folder, chk.name))
-                    else:
-                        checkpoints.append(chk.name)
-
-                best_checkpoint = next(
-                    (chk.name for chk in train_info.checkpoints if "best" in chk.name), None
+    def convert_train_to_experiment_info(
+        self, train_info: TrainInfo
+    ) -> Union[ExperimentInfo, None]:
+        try:
+            checkpoints = []
+            for chk in train_info.checkpoints:
+                if self.weights_folder:
+                    checkpoints.append(join(self.weights_folder, chk.name))
+                else:
+                    checkpoints.append(chk.name)
+
+            best_checkpoint = next(
+                (chk.name for chk in train_info.checkpoints if "best" in chk.name), None
+            )
+            if not best_checkpoint and checkpoints:
+                best_checkpoint = get_file_name_with_ext(checkpoints[-1])
+
+            task_info = self._api.task.get_info_by_id(train_info.task_id)
+            workspace_id = task_info["workspaceId"]
+
+            project = self._api.project.get_info_by_name(workspace_id, train_info.project_name)
+            project_id = project.id if project else None
+
+            model_files = {}
+            if train_info.config_path:
+                model_files["config"] = self.get_config_path(train_info.artifacts_folder).replace(
+                    train_info.artifacts_folder, ""
                 )
-                if not best_checkpoint and checkpoints:
-                    best_checkpoint = get_file_name_with_ext(checkpoints[-1])
-
-                task_info = api.task.get_info_by_id(train_info.task_id)
-                workspace_id = task_info["workspaceId"]
-
-                project = api.project.get_info_by_name(workspace_id, train_info.project_name)
-                project_id = project.id if project else None
-
-                model_files = {}
-                if train_info.config_path:
-                    model_files["config"] = self.get_config_path(
-                        train_info.artifacts_folder
-                    ).replace(train_info.artifacts_folder, "")
-
-                input_datetime = task_info["startedAt"]
-                parsed_datetime = datetime.strptime(input_datetime, "%Y-%m-%dT%H:%M:%S.%fZ")
-                date_time = parsed_datetime.strftime("%Y-%m-%d %H:%M:%S")
-
-                experiment_info_data = {
-                    "experiment_name": f"Unknown {self.framework_name} experiment",
-                    "framework_name": self.framework_name,
-                    "model_name": f"Unknown {self.framework_name} model",
-                    "task_type": train_info.task_type,
-                    "project_id": project_id,
-                    "task_id": train_info.task_id,
-                    "model_files": model_files,
-                    "checkpoints": checkpoints,
-                    "best_checkpoint": best_checkpoint,
-                    "artifacts_dir": train_info.artifacts_folder,
-                    "datetime": date_time,
-                }
-
-                experiment_info_fields = {
-                    field.name
-                    for field in ExperimentInfo.__dataclass_fields__.values()  # pylint: disable=no-member
-                }
-                for field in experiment_info_fields:
-                    if field not in experiment_info_data:
-                        experiment_info_data[field] = None
-
-                return ExperimentInfo(**experiment_info_data)
-            except Exception as e:
-                logger.debug(f"Failed to build experiment info: {e}")
-                return None
 
+            input_datetime = task_info["startedAt"]
+            parsed_datetime = datetime.strptime(input_datetime, "%Y-%m-%dT%H:%M:%S.%fZ")
+            date_time = parsed_datetime.strftime("%Y-%m-%d %H:%M:%S")
+
+            experiment_info_data = {
+                "experiment_name": f"Unknown {self.framework_name} experiment",
+                "framework_name": self.framework_name,
+                "model_name": f"Unknown {self.framework_name} model",
+                "task_type": train_info.task_type,
+                "project_id": project_id,
+                "task_id": train_info.task_id,
+                "model_files": model_files,
+                "checkpoints": checkpoints,
+                "best_checkpoint": best_checkpoint,
+                "artifacts_dir": train_info.artifacts_folder,
+                "datetime": date_time,
+            }
+
+            experiment_info_fields = {
+                field.name
+                for field in ExperimentInfo.__dataclass_fields__.values()  # pylint: disable=no-member
+            }
+            for field in experiment_info_fields:
+                if field not in experiment_info_data:
+                    experiment_info_data[field] = None
+            return ExperimentInfo(**experiment_info_data)
+        except Exception as e:
+            logger.debug(f"Failed to build experiment info: {e}")
+            return None
+
+    def get_list_experiment_info(
+        self, sort: Literal["desc", "asc"] = "desc"
+    ) -> List[ExperimentInfo]:
         train_infos = self.get_list(sort)
 
         # Sync version
@@ -607,7 +652,7 @@ class BaseTrainArtifacts:
         with ThreadPoolExecutor() as executor:
             experiment_infos = list(
                 executor.map(
-                    lambda t: build_experiment_info_from_train_info(self._api, t),
+                    lambda t: self.convert_train_to_experiment_info(t),
                     train_infos,
                 )
             )
@@ -621,3 +666,29 @@ class BaseTrainArtifacts:
         :rtype: List[str]
         """
         return self._available_task_types
+
+    def get_info_by_artifacts_dir(
+        self,
+        artifacts_dir: str,
+        return_type: Literal["train_info", "experiment_info"] = "train_info",
+    ) -> Union[TrainInfo, ExperimentInfo, None]:
+        """
+        Get training info by artifacts directory.
+
+        :param artifacts_dir: The artifacts directory.
+        :type artifacts_dir: str
+        :param return_type: The return type, either "train_info" or "experiment_info". Default is "experiment_info".
+        :type return_type: Literal["train_info", "experiment_info"]
+        :return: The training info.
+        :rtype: TrainInfo
+        """
+        for train_info in self.get_list():
+            if train_info.artifacts_folder == artifacts_dir:
+                if return_type == "train_info":
+                    return train_info
+                else:
+                    return self.convert_train_to_experiment_info(train_info)
+
+    # load_custom_checkpoint
+    # inference
+    # fix docstrings :param: x -> :param x:

{supervisely-6.73.302 → supervisely-6.73.303}/supervisely/nn/artifacts/detectron2.py

@@ -10,6 +10,11 @@ class Detectron2(BaseTrainArtifacts):
         super().__init__(team_id)
 
         self._app_name = "Train Detectron2"
+        self._slug = "supervisely-ecosystem/detectron2/supervisely/train"
+        self._serve_app_name = "Serve Detectron2"
+        self._serve_slug = (
+            "supervisely-ecosystem/detectron2/supervisely/instance_segmentation/serve"
+        )
         self._framework_name = "Detectron2"
         self._framework_folder = "/detectron2"
         self._weights_folder = "checkpoints"
@@ -19,6 +24,7 @@ class Detectron2(BaseTrainArtifacts):
         self._config_file = "model_config.yaml"
         self._pattern = re_compile(r"^/detectron2/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["instance segmentation"]
+        self._require_runtime = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

{supervisely-6.73.302 → supervisely-6.73.303}/supervisely/nn/artifacts/hrda.py

@@ -10,12 +10,16 @@ class HRDA(BaseTrainArtifacts):
         raise NotImplementedError
         # super().__init__(team_id)
         # self._app_name = "Train HRDA"
+        # self._serve_app_name = None
+        # self._slug = None
+        # self._serve_slug = None
         # self._framework_folder = "/HRDA"
         # self._weights_folder = None
         # self._task_type = "semantic segmentation"
         # self._weights_ext = ".pth"
         # self._config_file = "config.py"
         # self._available_task_types: List[str] = ["semantic segmentation"]
+        # self._require_runtime = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         raise NotImplementedError

{supervisely-6.73.302 → supervisely-6.73.303}/supervisely/nn/artifacts/mmclassification.py

@@ -10,6 +10,9 @@ class MMClassification(BaseTrainArtifacts):
         super().__init__(team_id)
 
         self._app_name = "Train MMClassification"
+        self._slug = "supervisely-ecosystem/mmclassification/supervisely/train"
+        self._serve_app_name = "Serve MMClassification"
+        self._serve_slug = "supervisely-ecosystem/mmclassification/supervisely/serve"
         self._framework_name = "MMClassification"
         self._framework_folder = "/mmclassification"
         self._weights_folder = "checkpoints"
@@ -17,6 +20,7 @@ class MMClassification(BaseTrainArtifacts):
         self._weights_ext = ".pth"
         self._pattern = re_compile(r"^/mmclassification/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["classification"]
+        self._require_runtime = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")