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

supervisely/api/image_api.py

@@ -70,6 +70,11 @@ from supervisely.api.module_api import (
     _get_single_item,
 )
 from supervisely.imaging import image as sly_image
+from supervisely.io.env import (
+    add_uploaded_ids_to_env,
+    app_categories,
+    increment_upload_count,
+)
 from supervisely.io.fs import (
     OFFSETS_PKL_BATCH_SIZE,
     OFFSETS_PKL_SUFFIX,
@@ -392,6 +397,9 @@ class ImageInfo(NamedTuple):
     #: Format: "YYYY-MM-DDTHH:MM:SS.sssZ"
     embeddings_updated_at: Optional[str] = None
 
+    #: :class:`int`: :class:`Dataset<supervisely.project.project.Project>` ID in Supervisely.
+    project_id: int = None
+
     # DO NOT DELETE THIS COMMENT
     #! New fields must be added with default values to keep backward compatibility.
 
@@ -471,6 +479,7 @@ class ImageApi(RemoveableBulkModuleApi):
             ApiField.OFFSET_END,
             ApiField.AI_SEARCH_META,
             ApiField.EMBEDDINGS_UPDATED_AT,
+            ApiField.PROJECT_ID,
         ]
 
     @staticmethod
@@ -2613,6 +2622,16 @@ class ImageApi(RemoveableBulkModuleApi):
                             info_json_copy[ApiField.EXT] = info_json[ApiField.MIME].split("/")[1]
                         # results.append(self.InfoType(*[info_json_copy[field_name] for field_name in self.info_sequence()]))
                         results.append(self._convert_json_info(info_json_copy))
+
+                    try:
+                        if "import" in app_categories():
+                            ids = [info.id for info in results[-len(batch_names) :]]
+                            if len(ids) > 0:
+                                increment_upload_count(dataset_id, len(ids))
+                                add_uploaded_ids_to_env(dataset_id, ids)
+                    except:
+                        pass
+
                     break
                 except HTTPError as e:
                     error_details = e.response.json().get("details", {})
@@ -5508,3 +5527,66 @@ class ImageApi(RemoveableBulkModuleApi):
             method,
             {ApiField.IMAGES: images},
         )
+
+    def get_subsequent_image_ids(
+        self,
+        image_id: int,
+        images_count: Optional[int] = None,
+        job_id: Optional[int] = None,
+        params: Optional[dict] = None,
+        dataset_id: Optional[int] = None,
+        project_id: Optional[int] = None,
+    ) -> List[int]:
+        """
+        Get list of subsequent image IDs after the specified image ID.
+
+        :param image_id: Image ID in Supervisely.
+        :type image_id: int
+        :param images_count: Number of subsequent images to retrieve. If None, retrieves all subsequent images.
+        :type images_count: int, optional
+        :param job_id: Job ID to filter images. If None, does not filter by job ID.
+        :type job_id: int, optional
+        :param params: Additional parameters for filtering and sorting images.
+        :type params: dict, optional
+        :param dataset_id: Dataset ID to filter images.
+        :type dataset_id: int, optional
+        :param project_id: Project ID to filter images. If None, makes a request to retrieve it from the specified image.
+        :type project_id: int, optional
+        """
+        data = {
+            "recursive": True,
+            "projectId": project_id,
+            "filters": [],
+            "sort": "name",
+            "sort_order": "asc",
+        }
+
+        if params is not None:
+            data.update(params)
+
+        if data["projectId"] is None:
+            image_info = self.get_info_by_id(image_id)
+            if image_info is None:
+                raise ValueError(f"Image with ID {image_id} not found.")
+            project_id = self._api.dataset.get_info_by_id(image_info.dataset_id).project_id
+        if job_id is not None:
+            self._api.add_header("x-job-id", str(job_id))
+        if dataset_id is not None:
+            data["datasetId"] = dataset_id
+
+        image_infos = self.get_list_all_pages(
+            "images.list",
+            data,
+            limit=None,
+            return_first_response=False,
+        )
+        self._api.headers.pop("x-job-id", None)
+        image_ids = [img_info.id for img_info in image_infos]
+        if len(image_ids) == 0:
+            raise ValueError("No images found with the specified criteria.")
+        elif image_id not in image_ids:
+            raise ValueError(f"Image with ID {image_id} not found in the specified entity.")
+
+        target_idx = image_ids.index(image_id) + 1
+        to_idx = target_idx + images_count if images_count is not None else len(image_ids)
+        return image_ids[target_idx:to_idx]

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"
@@ -703,6 +707,12 @@ class ApiField:
     """"""
     ERROR_MESSAGE = "errorMessage"
     """"""
+    UNIQUE_ITEMS = "uniqueItems"
+    """"""
+    NN_CREATED = "nnCreated"
+    """"""
+    NN_UPDATED = "nnUpdated"
+    """"""
 
 
 def _get_single_item(items):

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/pointcloud/pointcloud_api.py

@@ -1431,3 +1431,41 @@ class PointcloudApi(RemoveableBulkModuleApi):
             )
             tasks.append(task)
         await asyncio.gather(*tasks)
+
+    def rename(
+        self,
+        id: int,
+        name: str,
+    ) -> PointcloudInfo:
+        """Renames Pointcloud with given ID to a new name.
+
+        :param id: Pointcloud ID in Supervisely.
+        :type id: int
+        :param name: New Pointcloud name.
+        :type name: str
+        :return: Information about updated Pointcloud.
+        :rtype: :class:`PointcloudInfo`
+
+        :Usage example:
+
+        .. code-block:: python
+
+            import supervisely as sly
+
+            api = sly.Api.from_env()
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+
+            pointcloud_id = 123456
+            new_pointcloud_name = "3333_new.pcd"
+
+            api.pointcloud.rename(id=pointcloud_id, name=new_pointcloud_name)
+        """
+
+        data = {
+            ApiField.ID: id,
+            ApiField.NAME: name,
+        }
+
+        response = self._api.post("images.editInfo", data)
+        return self._convert_json_info(response.json())

supervisely/api/pointcloud/pointcloud_episode_annotation_api.py

@@ -107,6 +107,9 @@ class PointcloudEpisodeAnnotationAPI(EntityAnnotationAPI):
         """
 
         response = self._api.post(self._method_download, {ApiField.DATASET_ID: dataset_id})
+        result = response.json()
+        if len(result) == 0:
+            return PointcloudEpisodeAnnotation().to_json()
         return response.json()[0]
 
     def download_bulk(self, dataset_id, entity_ids):