supervisely 6.73.419__py3-none-any.whl → 6.73.421__py3-none-any.whl

supervisely/api/api.py

@@ -723,6 +723,7 @@ class Api:
         retries: Optional[int] = None,
         stream: Optional[bool] = False,
         use_public_api: Optional[bool] = True,
+        data: Optional[Dict] = None,
     ) -> requests.Response:
         """
         Performs GET request to server with given parameters.
@@ -730,13 +731,15 @@ class Api:
         :param method:
         :type method: str
         :param params: Dictionary to send in the body of the :class:`Request`.
-        :type method: dict
+        :type params: dict
         :param retries: The number of attempts to connect to the server.
-        :type method: int, optional
+        :type retries: int, optional
         :param stream: Define, if you'd like to get the raw socket response from the server.
-        :type method: bool, optional
+        :type stream: bool, optional
         :param use_public_api:
-        :type method: bool, optional
+        :type use_public_api: bool, optional
+        :param data: Dictionary to send in the body of the :class:`Request`.
+        :type data: dict, optional
         :return: Response object
         :rtype: :class:`Response<Response>`
         """
@@ -756,7 +759,9 @@ class Api:
                 json_body = params
                 if type(params) is dict:
                     json_body = {**params, **self.additional_fields}
-                response = requests.get(url, params=json_body, headers=self.headers, stream=stream)
+                response = requests.get(
+                    url, params=json_body, data=data, headers=self.headers, stream=stream
+                )
 
                 if response.status_code != requests.codes.ok:  # pylint: disable=no-member
                     Api._raise_for_status(response)

supervisely/api/app_api.py

@@ -1394,9 +1394,75 @@ class AppApi(TaskApi):
         """get_url"""
         return f"/apps/sessions/{task_id}"
 
-    def download_git_file(self, app_id, version, file_path, save_path):
-        """download_git_file"""
-        raise NotImplementedError()
+    def download_git_file(
+        self,
+        module_id,
+        save_path,
+        app_id=None,
+        version=None,
+        file_path=None,
+        file_key=None,
+        log_progress=True,
+        ext_logger=None,
+    ):
+        """
+        Download a file from app repository. File should be added in the app config under `files` key.
+
+        :param module_id: ID of the module
+        :type module_id: int
+        :param save_path: Path to save the file
+        :type save_path: str
+        :param app_id: ID of the app
+        :type app_id: int
+        :param version: Version of the app
+        :type version: str
+        :param file_path: Path to the file in the app github repository
+        :type file_path: str
+        :param file_key: Key of the file in the app github repository
+        :type file_key: str
+        :param log_progress: If True, will log the progress of the download
+        :type log_progress: bool
+        :param ext_logger: Logger to use for logging
+        :type ext_logger: Logger
+        :return: None
+        :rtype: None
+        """
+        if file_path is None and file_key is None:
+            raise ValueError("Either file_path or file_key must be provided")
+        payload = {
+            ApiField.MODULE_ID: module_id,
+        }
+        if version is not None:
+            payload[ApiField.VERSION] = version
+        if app_id is not None:
+            payload[ApiField.APP_ID] = app_id
+        if file_path is not None:
+            payload[ApiField.FILE_PATH] = file_path
+        if file_key is not None:
+            payload[ApiField.FILE_KEY] = file_key
+
+        response = self._api.post("ecosystem.file.download", payload, stream=True)
+        progress = None
+        if log_progress:
+            if ext_logger is None:
+                ext_logger = logger
+
+            length = None
+            # Content-Length
+            if "Content-Length" in response.headers:
+                length = int(response.headers["Content-Length"])
+            progress = Progress("Downloading: ", length, ext_logger=ext_logger, is_size=True)
+
+        mb1 = 1024 * 1024
+        ensure_base_path(save_path)
+        with open(save_path, "wb") as fd:
+            log_size = 0
+            for chunk in response.iter_content(chunk_size=mb1):
+                fd.write(chunk)
+                log_size += len(chunk)
+                if log_progress and log_size > mb1 and progress is not None:
+                    progress.iters_done_report(log_size)
+                    log_size = 0
 
     def download_git_archive(
         self,
@@ -1418,6 +1484,7 @@ class AppApi(TaskApi):
             payload[ApiField.APP_ID] = app_id
 
         response = self._api.post("ecosystem.file.download", payload, stream=True)
+        progress = None
         if log_progress:
             if ext_logger is None:
                 ext_logger = logger
@@ -1435,7 +1502,7 @@ class AppApi(TaskApi):
             for chunk in response.iter_content(chunk_size=mb1):
                 fd.write(chunk)
                 log_size += len(chunk)
-                if log_progress and log_size > mb1:
+                if log_progress and log_size > mb1 and progress is not None:
                     progress.iters_done_report(log_size)
                     log_size = 0
 

supervisely/api/module_api.py

@@ -691,6 +691,10 @@ class ApiField:
     """"""
     UPDATE_STRATEGY = "updateStrategy"
     """"""
+    FILE_PATH = "filePath"
+    """"""
+    FILE_KEY = "fileKey"
+    """"""
     LOCAL_ENTITIES_COUNT = "localEntitiesCount"
     """"""
     REMOTE_ENTITIES_COUNT = "remoteEntitiesCount"

supervisely/api/nn/deploy_api.py

@@ -157,16 +157,15 @@ class DeployApi:
             "device": device,
             "model_source": ModelSource.CUSTOM,
             "model_files": {
-                "checkpoint": Path(
-                    experiment_info.artifacts_dir, "checkpoints", checkpoint_name
-                ).as_posix(),
-                "config": Path(
-                    experiment_info.artifacts_dir, experiment_info.model_files["config"]
-                ).as_posix(),
+                key: Path(experiment_info.artifacts_dir, value).as_posix()
+                for key, value in experiment_info.model_files.items()
             },
             "model_info": experiment_info.to_json(),
             "runtime": runtime,
         }
+        deploy_params["model_files"]["checkpoint"] = Path(
+            experiment_info.artifacts_dir, "checkpoints", checkpoint_name
+        ).as_posix()
         self._load_model_from_api(session_id, deploy_params)
 
     def _find_agent(self, team_id: int = None, public=True, gpu=True):
@@ -239,6 +238,7 @@ class DeployApi:
             RTDETR,
             Detectron2,
             MMClassification,
+            MMPretrain,
             MMDetection,
             MMDetection3,
             MMSegmentation,
@@ -262,6 +262,7 @@ class DeployApi:
             RTDETR(team_id).framework_name: RTDETR(team_id).serve_slug,
             Detectron2(team_id).framework_name: Detectron2(team_id).serve_slug,
             MMClassification(team_id).framework_name: MMClassification(team_id).serve_slug,
+            MMPretrain(team_id).framework_name: MMPretrain(team_id).serve_slug,
             MMDetection(team_id).framework_name: MMDetection(team_id).serve_slug,
             MMDetection3(team_id).framework_name: MMDetection3(team_id).serve_slug,
             MMSegmentation(team_id).framework_name: MMSegmentation(team_id).serve_slug,
@@ -547,7 +548,6 @@ class DeployApi:
         _attempt_delay_sec = 1
         _attempts = timeout // _attempt_delay_sec
 
-        # @TODO: Run app in team?
         if workspace_id is None:
             workspace_id = env.workspace_id()
         kwargs = get_valid_kwargs(
@@ -768,10 +768,14 @@ class DeployApi:
         for file_key, file_path in experiment_info.model_files.items():
             full_file_path = os.path.join(experiment_info.artifacts_dir, file_path)
             if not self._api.file.exists(team_id, full_file_path):
-                logger.debug(f"Model file not found: '{full_file_path}'. Trying to find it by checkpoint path.")
+                logger.debug(
+                    f"Model file not found: '{full_file_path}'. Trying to find it by checkpoint path."
+                )
                 full_file_path = os.path.join(artifacts_dir, file_path)
                 if not self._api.file.exists(team_id, full_file_path):
-                    raise ValueError(f"Model file not found: '{full_file_path}'. Make sure that the file exists in the artifacts directory.")
+                    raise ValueError(
+                        f"Model file not found: '{full_file_path}'. Make sure that the file exists in the artifacts directory."
+                    )
             deploy_params["model_files"][file_key] = full_file_path
             logger.debug(f"Model file added: {full_file_path}")
         return module_id, serve_app_name, deploy_params
@@ -845,6 +849,7 @@ class DeployApi:
             RTDETR,
             Detectron2,
             MMClassification,
+            MMPretrain,
             MMDetection,
             MMDetection3,
             MMSegmentation,
@@ -863,6 +868,7 @@ class DeployApi:
         frameworks = {
             "/detectron2": Detectron2,
             "/mmclassification": MMClassification,
+            "/mmclassification-v2": MMPretrain,
             "/mmdetection": MMDetection,
             "/mmdetection-3": MMDetection3,
             "/mmsegmentation": MMSegmentation,

supervisely/api/nn/ecosystem_models_api.py

@@ -0,0 +1,201 @@
+from typing import List, Literal
+
+from supervisely.api.api import Api
+from supervisely.api.module_api import ApiField, ModuleApi
+
+
+class ModelApiField:
+    NAME = "name"
+    FRAMEWORK = "framework"
+    TASK_TYPE = "task"
+    MODALITY = "modality"
+    TRAIN_MODULE_ID = "trainModuleId"
+    SERVE_MODULE_ID = "serveModuleId"
+    ARCHITECTURE = "architecture"
+    PRETRAINED = "pretrained"
+    NUM_CLASSES = "numClasses"
+    SIZE = "size"
+    PARAMS_M = "paramsM"
+    GFLOPS = "GFLOPs"
+    TAGS = "tags"
+    RUNTIMES = "runtimes"
+    FILES = "files"
+    SPEED_TESTS = "speedTests"
+    EVALUATION = "evaluation"
+
+
+class EcosystemModelsApi(ModuleApi):
+
+    def __init__(self, api: Api):
+        self._api = api
+
+    def _convert_json_info(self, json_info):
+        return json_info
+
+    def get_list_all_pages(
+        self,
+        method,
+        data,
+        progress_cb=None,
+        convert_json_info_cb=None,
+        limit: int = None,
+        return_first_response: bool = False,
+    ):
+        """
+        Get list of all or limited quantity entities from the Supervisely server.
+
+        :param method: Request method name
+        :type method: str
+        :param data: Dictionary with request body info
+        :type data: dict
+        :param progress_cb: Function for tracking download progress.
+        :type progress_cb: Progress, optional
+        :param convert_json_info_cb: Function for convert json info
+        :type convert_json_info_cb: Callable, optional
+        :param limit: Number of entity to retrieve
+        :type limit: int, optional
+        :param return_first_response: Specify if return first response
+        :type return_first_response: bool, optional
+        """
+
+        if convert_json_info_cb is None:
+            convert_func = self._convert_json_info
+        else:
+            convert_func = convert_json_info_cb
+
+        if ApiField.SORT not in data:
+            data = self._add_sort_param(data)
+        first_response = self._api.get(method, {}, data=data).json()
+        total = first_response["total"]
+        per_page = first_response["perPage"]
+        pages_count = first_response["pagesCount"]
+
+        limit_exceeded = False
+        results = first_response["entities"]
+        if limit is not None and len(results) > limit:
+            limit_exceeded = True
+
+        if progress_cb is not None:
+            progress_cb(len(results))
+        if (pages_count == 1 and len(results) == total) or limit_exceeded is True:
+            pass
+        else:
+            for page_idx in range(2, pages_count + 1):
+                temp_resp = self._api.get(
+                    method, {}, data={**data, "page": page_idx, "per_page": per_page}
+                )
+                temp_items = temp_resp.json()["entities"]
+                results.extend(temp_items)
+                if progress_cb is not None:
+                    progress_cb(len(temp_items))
+                if limit is not None and len(results) > limit:
+                    limit_exceeded = True
+                    break
+
+            if len(results) != total and limit is None:
+                raise RuntimeError(
+                    "Method {!r}: error during pagination, some items are missed".format(method)
+                )
+
+        if limit is not None:
+            results = results[:limit]
+        if return_first_response:
+            return [convert_func(item) for item in results], first_response
+        return [convert_func(item) for item in results]
+
+    def list_models(self, local=False):
+        method = "ecosystem.models.list"
+        data = {"localModels": local}
+        return self.get_list_all_pages(method, data=data)
+
+    def add(
+        self,
+        name: str,
+        framework: str,
+        task_type: str,
+        tain_module_id: int,
+        serve_module_id: int,
+        modality: Literal["images", "videos"] = "images",
+        architecture: str = None,
+        pretrained: bool = False,
+        num_classes: int = None,
+        size: int = None,
+        params_m: int = None,
+        gflops: float = None,
+        tags: List[str] = None,
+        runtimes: List[str] = None,
+        files: List[str] = None,
+        speed_tests: List = None,
+        evaluation: dict = None,
+    ):
+        method = "ecosystem.models.add"
+        data = {
+            ModelApiField.NAME: name,
+            ModelApiField.FRAMEWORK: framework,
+            ModelApiField.TASK_TYPE: task_type,
+            ModelApiField.MODALITY: modality,
+            ModelApiField.TRAIN_MODULE_ID: tain_module_id,
+            ModelApiField.SERVE_MODULE_ID: serve_module_id,
+        }
+        optional_fields = {
+            ModelApiField.ARCHITECTURE: architecture,
+            ModelApiField.PRETRAINED: pretrained,
+            ModelApiField.NUM_CLASSES: num_classes,
+            ModelApiField.SIZE: size,
+            ModelApiField.PARAMS_M: params_m,
+            ModelApiField.GFLOPS: gflops,
+            ModelApiField.TAGS: tags,
+            ModelApiField.RUNTIMES: runtimes,
+            ModelApiField.FILES: files,
+            ModelApiField.SPEED_TESTS: speed_tests,
+            ModelApiField.EVALUATION: evaluation,
+        }
+        for key, value in optional_fields.items():
+            if value is not None:
+                data[key] = value
+        return self._api.post(method, data=data)
+
+    def update_model(
+        self,
+        model_id: int,
+        name: str = None,
+        framework: str = None,
+        task_type: str = None,
+        tain_module_id: int = None,
+        serve_module_id: int = None,
+        modality: Literal["images", "videos"] = None,
+        architecture: str = None,
+        pretrained: bool = False,
+        num_classes: int = None,
+        size: int = None,
+        params_m: int = None,
+        gflops: float = None,
+        tags: List[str] = None,
+        runtimes: List[str] = None,
+        files: List[str] = None,
+        speed_tests: List = None,
+        evaluation: dict = None,
+    ):
+        data = {
+            ModelApiField.NAME: name,
+            ModelApiField.FRAMEWORK: framework,
+            ModelApiField.TASK_TYPE: task_type,
+            ModelApiField.MODALITY: modality,
+            ModelApiField.TRAIN_MODULE_ID: tain_module_id,
+            ModelApiField.SERVE_MODULE_ID: serve_module_id,
+            ModelApiField.ARCHITECTURE: architecture,
+            ModelApiField.PRETRAINED: pretrained,
+            ModelApiField.NUM_CLASSES: num_classes,
+            ModelApiField.SIZE: size,
+            ModelApiField.PARAMS_M: params_m,
+            ModelApiField.GFLOPS: gflops,
+            ModelApiField.TAGS: tags,
+            ModelApiField.RUNTIMES: runtimes,
+            ModelApiField.FILES: files,
+            ModelApiField.SPEED_TESTS: speed_tests,
+            ModelApiField.EVALUATION: evaluation,
+        }
+        data = {k: v for k, v in data.items() if v is not None}
+        method = "ecosystem.models.update"
+        data["id"] = model_id
+        return self._api.post(method, data=data)

supervisely/api/nn/neural_network_api.py

@@ -23,9 +23,11 @@ class NeuralNetworkApi:
 
     def __init__(self, api: "Api"):
         from supervisely.api.nn.deploy_api import DeployApi
+        from supervisely.api.nn.ecosystem_models_api import EcosystemModelsApi
 
         self._api = api
         self._deploy_api = DeployApi(api)
+        self.ecosystem_models_api = EcosystemModelsApi(api)
 
     def deploy(
         self,
@@ -168,7 +170,7 @@ class NeuralNetworkApi:
             workspaces = [workspace_id]
         elif team_id is not None:
             workspaces = self._api.workspace.get_list(team_id)
-            workspaces = [workspace["id"] for workspace in workspaces]
+            workspaces = [workspace.id for workspace in workspaces]
         else:
             workspace_id = env.workspace_id(raise_not_found=False)
             if workspace_id is None:
@@ -178,7 +180,7 @@ class NeuralNetworkApi:
                         "Workspace ID and Team ID are not specified and cannot be found in the environment."
                     )
                 workspaces = self._api.workspace.get_list(team_id)
-                workspaces = [workspace["id"] for workspace in workspaces]
+                workspaces = [workspace.id for workspace in workspaces]
             else:
                 workspaces = [workspace_id]
 
@@ -202,7 +204,14 @@ class NeuralNetworkApi:
         # get deploy infos and filter results
         result = []
         for task in all_tasks:
-            deploy_info = self._deploy_api.get_deploy_info(task["id"])
+            try:
+                deploy_info = self._deploy_api.get_deploy_info(task["id"])
+            except Exception as e:
+                logger.warning(
+                    f"Failed to get deploy info for task {task['id']}: {e}",
+                    exc_info=True,
+                )
+                continue
             if model is not None:
                 checkpoint = deploy_info["checkpoint_name"]
                 deployed_model = deploy_info["model_name"]

supervisely/api/project_api.py

@@ -264,9 +264,10 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
 
     def get_list(
         self,
-        workspace_id: int,
+        workspace_id: Optional[int] = None,
         filters: Optional[List[Dict[str, str]]] = None,
         fields: List[str] = [],
+        team_id: Optional[int] = None,
     ) -> List[ProjectInfo]:
         """
         List of Projects in the given Workspace.
@@ -275,12 +276,13 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
         If you need version information, use :func:`get_info_by_id`.
 
         :param workspace_id: Workspace ID in which the Projects are located.
-        :type workspace_id: int
+        :type workspace_id: int, optional
         :param filters: List of params to sort output Projects.
         :type filters: List[dict], optional
         :param fields: The list of api fields which will be returned with the response. You must specify all fields you want to receive, not just additional ones.
         :type fields: List[str]
-
+        :param team_id: Team ID in which the Projects are located.
+        :type team_id: int, optional
         :return: List of all projects with information for the given Workspace. See :class:`info_sequence<info_sequence>`
         :rtype: :class: `List[ProjectInfo]`
         :Usage example:
@@ -357,6 +359,11 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             # ]
 
         """
+        if team_id is not None and workspace_id is not None:
+            raise ValueError(
+                "team_id and workspace_id cannot be used together. Please provide only one of them."
+            )
+
         method = "projects.list"
 
         debug_message = "While getting list of projects, the following fields are not available: "
@@ -367,11 +374,33 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
                 self.debug_messages_sent["get_list_versions"] = True
                 logger.debug(debug_message + "version. ")
 
+        default_fields = [
+            ApiField.ID,
+            ApiField.WORKSPACE_ID,
+            ApiField.TITLE,
+            ApiField.DESCRIPTION,
+            ApiField.SIZE,
+            ApiField.README,
+            ApiField.TYPE,
+            ApiField.CREATED_AT,
+            ApiField.UPDATED_AT,
+            ApiField.CUSTOM_DATA,
+            ApiField.GROUP_ID,
+            ApiField.CREATED_BY_ID[0][0],
+        ]
+
+        if fields:
+            merged_fields = list(set(default_fields + fields))
+            fields = list(dict.fromkeys(merged_fields))
+
         data = {
-            ApiField.WORKSPACE_ID: workspace_id,
             ApiField.FILTER: filters or [],
             ApiField.FIELDS: fields,
         }
+        if workspace_id is not None:
+            data[ApiField.WORKSPACE_ID] = workspace_id
+        if team_id is not None:
+            data[ApiField.GROUP_ID] = team_id
 
         return self.get_list_all_pages(method, data)
 
@@ -2129,7 +2158,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             #                       reference_image_url = None,
             #                       custom_data = None,
             #                       backup_archive = None,
-            #                       teamd_id = 1,
+            #                       team_id = 1,
             #                       import_settings = {},
             #                   ),
             #                   ProjectInfo(id = 23,
@@ -2147,7 +2176,7 @@ class ProjectApi(CloneableModuleApi, UpdateableModule, RemoveableModuleApi):
             #                       reference_image_url = None,
             #                       custom_data = None,
             #                       backup_archive = None),
-            #                       teamd_id = 1,
+            #                       team_id = 1,
             #                       import_settings = {},
             #                   )
             #                 ]

supervisely/api/task_api.py

@@ -1007,11 +1007,12 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         Example of experiment_info:
 
             experiment_info = {
-                'experiment_name': '247_Lemons_RT-DETRv2-M',
+                'experiment_name': '247 Lemons RT-DETRv2-M',
                 'framework_name': 'RT-DETRv2',
                 'model_name': 'RT-DETRv2-M',
                 'task_type': 'object detection',
                 'project_id': 76,
+                'project_version': {'id': 222, 'version': 4},
                 'task_id': 247,
                 'model_files': {'config': 'model_config.yml'},
                 'checkpoints': ['checkpoints/best.pth', 'checkpoints/checkpoint0025.pth', 'checkpoints/checkpoint0050.pth', 'checkpoints/last.pth'],
@@ -1022,10 +1023,13 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
                 'train_val_split': 'train_val_split.json',
                 'train_size': 4,
                 'val_size': 2,
+                'train_collection_id': 530,
+                'val_collection_id': 531,
                 'hyperparameters': 'hyperparameters.yaml',
                 'hyperparameters_id': 45234,
                 'artifacts_dir': '/experiments/76_Lemons/247_RT-DETRv2/',
                 'datetime': '2025-01-22 18:13:43',
+                'experiment_report_id': 87654,
                 'evaluation_report_id': 12961,
                 'evaluation_report_link': 'https://app.supervisely.com/model-benchmark?id=12961',
                 'evaluation_metrics': {

supervisely/app/widgets/__init__.py

@@ -151,4 +151,11 @@ from supervisely.app.widgets.experiment_selector.experiment_selector import Expe
 from supervisely.app.widgets.bokeh.bokeh import Bokeh
 from supervisely.app.widgets.run_app_button.run_app_button import RunAppButton
 from supervisely.app.widgets.select_collection.select_collection import SelectCollection
-from supervisely.app.widgets.sampling.sampling import Sampling
+from supervisely.app.widgets.sampling.sampling import Sampling
+from supervisely.app.widgets.deploy_model.deploy_model import DeployModel
+from supervisely.app.widgets.dropdown_checkbox_selector.dropdown_checkbox_selector import (
+    DropdownCheckboxSelector,
+)
+from supervisely.app.widgets.ecosystem_model_selector.ecosystem_model_selector import (
+    EcosystemModelSelector,
+)

supervisely/app/widgets/agent_selector/template.html

@@ -5,6 +5,7 @@
         :group-id="data.{{{ widget.widget_id }}}.teamId" 
         :options="state.{{{ widget.widget_id }}}.options"
 	    :is-community="data.{{{ widget.widget_id }}}.isCommunity" 
+        :disabled="data.{{{ widget.widget_id }}}.disabled"
         {% if widget._changes_handled == true %} 
             @input="state.{{{ widget.widget_id }}}.agentId = $event; post('/{{{ widget.widget_id }}}/value_changed')"
         {% else %}