supervisely 6.73.301__py3-none-any.whl → 6.73.303__py3-none-any.whl

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/convert/__init__.py

@@ -3,14 +3,30 @@
 # Project
 from supervisely.convert.image.coco.coco_helper import sly_project_to_coco as project_to_coco
 from supervisely.convert.image.yolo.yolo_helper import sly_project_to_yolo as project_to_yolo
-from supervisely.convert.image.pascal_voc.pascal_voc_helper import sly_project_to_pascal_voc as project_to_pascal_voc
+from supervisely.convert.image.pascal_voc.pascal_voc_helper import (
+    sly_project_to_pascal_voc as project_to_pascal_voc,
+)
 
 # Dataset
 from supervisely.convert.image.coco.coco_helper import sly_ds_to_coco as dataset_to_coco
 from supervisely.convert.image.yolo.yolo_helper import sly_ds_to_yolo as dataset_to_yolo
-from supervisely.convert.image.pascal_voc.pascal_voc_helper import sly_ds_to_pascal_voc as dataset_to_pascal_voc
+from supervisely.convert.image.pascal_voc.pascal_voc_helper import (
+    sly_ds_to_pascal_voc as dataset_to_pascal_voc,
+)
 
 # Image Annotations
 from supervisely.convert.image.coco.coco_helper import sly_ann_to_coco as annotation_to_coco
 from supervisely.convert.image.yolo.yolo_helper import sly_ann_to_yolo as annotation_to_yolo
-from supervisely.convert.image.pascal_voc.pascal_voc_helper import sly_ann_to_pascal_voc as annotation_to_pascal_voc
+from supervisely.convert.image.pascal_voc.pascal_voc_helper import (
+    sly_ann_to_pascal_voc as annotation_to_pascal_voc,
+)
+
+
+# Supervisely Project/Dataset/Annotation to COCO
+from supervisely.convert.image.coco.coco_helper import to_coco
+
+# Supervisely Project/Dataset/Annotation to YOLO
+from supervisely.convert.image.yolo.yolo_helper import to_yolo
+
+# Supervisely Project/Dataset/Annotation to Pascal VOC
+from supervisely.convert.image.pascal_voc.pascal_voc_helper import to_pascal_voc

supervisely/convert/image/coco/coco_helper.py

@@ -4,6 +4,7 @@ import sys
 import uuid
 from copy import deepcopy
 from datetime import datetime
+from itertools import groupby
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
 
@@ -351,7 +352,8 @@ def _get_graph_info(idx, obj_class):
     return data
 
 
-def get_categories_from_meta(meta: ProjectMeta):
+def get_categories_from_meta(meta: ProjectMeta) -> List[Dict[str, Any]]:
+    """Get categories from Supervisely project meta."""
     cat = lambda idx, c: {"supercategory": c.name, "id": idx, "name": c.name}
     return [
         cat(idx, c) if c.geometry_type != GraphNodes else _get_graph_info(idx, c)
@@ -359,6 +361,34 @@ def get_categories_from_meta(meta: ProjectMeta):
     ]
 
 
+def extend_mask_up_to_image(
+    binary_mask: np.ndarray, image_shape: Tuple[int, int], origin: PointLocation
+) -> np.ndarray:
+    """Extend binary mask up to image shape."""
+    y, x = origin.col, origin.row
+    new_mask = np.zeros(image_shape, dtype=binary_mask.dtype)
+    try:
+        new_mask[x : x + binary_mask.shape[0], y : y + binary_mask.shape[1]] = binary_mask
+    except ValueError as e:
+        raise ValueError(
+            f"Binary mask size {binary_mask.shape} with origin {origin} "
+            f"exceeds image boundaries {image_shape}"
+        ) from e
+    return new_mask
+
+
+def coco_segmentation_rle(segmentation: np.ndarray) -> Dict[str, Any]:
+    """Convert COCO segmentation to RLE format."""
+    binary_mask = np.asfortranarray(segmentation)
+    rle = {"counts": [], "size": list(binary_mask.shape)}
+    counts = rle.get("counts")
+    for i, (value, elements) in enumerate(groupby(binary_mask.ravel(order="F"))):
+        if i == 0 and value == 1:
+            counts.append(0)
+        counts.append(len(list(elements)))
+    return rle
+
+
 def sly_ann_to_coco(
     ann: Annotation,
     coco_image_id: int,
@@ -491,17 +521,14 @@ def sly_ann_to_coco(
 
     res_inst = []  # result list of COCO objects
 
+    h, w = ann.img_size
     for binding_key, labels in ann.get_bindings().items():
         if binding_key is None:
             polygons = [l for l in labels if l.obj_class.geometry_type == Polygon]
             masks = [l for l in labels if l.obj_class.geometry_type == Bitmap]
             bboxes = [l for l in labels if l.obj_class.geometry_type == Rectangle]
             graphs = [l for l in labels if l.obj_class.geometry_type == GraphNodes]
-            if len(masks) > 0:
-                for l in masks:
-                    polygon_cls = l.obj_class.clone(geometry_type=Polygon)
-                    polygons.extend(l.convert(polygon_cls))
-            for label in polygons + bboxes:
+            for label in polygons + bboxes + masks:
                 cat_id = class_mapping[label.obj_class.name]
                 coco_obj = coco_obj_template(label_id, coco_image_id, cat_id)
                 coco_obj["bbox"] = _get_common_bbox([label])
@@ -510,6 +537,11 @@ def sly_ann_to_coco(
                     poly = label.geometry.to_json()["points"]["exterior"]
                     poly = np.array(poly).flatten().astype(float).tolist()
                     coco_obj["segmentation"] = [poly]
+                elif label.obj_class.geometry_type == Bitmap:
+                    segmentation = extend_mask_up_to_image(
+                        label.geometry.data, (h, w), label.geometry.origin
+                    )
+                    coco_obj["segmentation"] = coco_segmentation_rle(segmentation)
 
                 label_id = _update_inst_results(label_id, coco_ann, coco_obj, res_inst)
 
@@ -525,38 +557,60 @@ def sly_ann_to_coco(
         masks = [l for l in labels if l.obj_class.geometry_type == Bitmap]
         graphs = [l for l in labels if l.obj_class.geometry_type == GraphNodes]
 
-        if len(masks) > 0:  # convert Bitmap to Polygon
-            for l in masks:
-                polygon_cls = l.obj_class.clone(geometry_type=Polygon)
-                polygons.extend(l.convert(polygon_cls))
+        need_to_process_separately = len(masks) > 0 and len(polygons) > 0
+        bbox_matched_w_mask = False
+        bbox_matched_w_poly = False
 
-        matched_bbox = False
-        if len(polygons) > 0:  # process polygons
+        if len(graphs) > 0:
+            if len(masks) > 0 or len(polygons) > 0:
+                logger.warning(
+                    "Keypoints and Polygons/Bitmaps in one binding key are not supported. "
+                    "Objects will be converted separately."
+                )
+            if len(graphs) > 1:
+                logger.warning(
+                    "Multiple Keypoints in one binding key are not supported. "
+                    "Only the first graph will be converted."
+                )
+            cat_id = class_mapping[graphs[0].obj_class.name]
+            coco_obj = _create_keypoints_obj(graphs[0], cat_id, label_id, coco_image_id)
+            label_id = _update_inst_results(label_id, coco_ann, coco_obj, res_inst)
+
+        # convert Bitmap to Polygon
+        if len(masks) > 0:
+            for label in masks:
+                cat_id = class_mapping[label.obj_class.name]
+                coco_obj = coco_obj_template(label_id, coco_image_id, cat_id)
+                segmentation = extend_mask_up_to_image(
+                    label.geometry.data, (h, w), label.geometry.origin
+                )
+                coco_obj["segmentation"] = coco_segmentation_rle(segmentation)
+                coco_obj["area"] = label.geometry.area
+                if len(bboxes) > 0 and not need_to_process_separately:
+                    found = _get_common_bbox(bboxes, sly_bbox=True, approx=True)
+                    new = _get_common_bbox([label], sly_bbox=True)
+                    bbox_matched_w_mask = found.contains(new)
+                coco_obj["bbox"] = _get_common_bbox(bboxes if bbox_matched_w_mask else [label])
+                label_id = _update_inst_results(label_id, coco_ann, coco_obj, res_inst)
+
+        # process polygons
+        if len(polygons) > 0:
             cat_id = class_mapping[polygons[0].obj_class.name]
             coco_obj = coco_obj_template(label_id, coco_image_id, cat_id)
-            if len(bboxes) > 0:
+            if len(bboxes) > 0 and not need_to_process_separately:
                 found = _get_common_bbox(bboxes, sly_bbox=True, approx=True)
                 new = _get_common_bbox(polygons, sly_bbox=True)
-                matched_bbox = found.contains(new)
+                bbox_matched_w_poly = found.contains(new)
 
             polys = [l.geometry.to_json()["points"]["exterior"] for l in polygons]
             polys = [np.array(p).flatten().astype(float).tolist() for p in polys]
             coco_obj["segmentation"] = polys
             coco_obj["area"] = sum([l.geometry.area for l in polygons])
-            coco_obj["bbox"] = _get_common_bbox(bboxes if matched_bbox else polygons)
-            label_id = _update_inst_results(label_id, coco_ann, coco_obj, res_inst)
-
-        if len(graphs) > 0:
-            if len(graphs) > 1:
-                logger.warning(
-                    "Multiple Keypoints in one binding key are not supported. "
-                    "Only the first graph will be converted."
-                )
-            cat_id = class_mapping[graphs[0].obj_class.name]
-            coco_obj = _create_keypoints_obj(graphs[0], cat_id, label_id, coco_image_id)
+            coco_obj["bbox"] = _get_common_bbox(bboxes if bbox_matched_w_poly else polygons)
             label_id = _update_inst_results(label_id, coco_ann, coco_obj, res_inst)
 
-        if len(bboxes) > 0 and not matched_bbox:  # process bboxes separately
+        # process bboxes separately if they are not matched with masks/polygons
+        if len(bboxes) > 0 and not bbox_matched_w_poly and not bbox_matched_w_mask:
             for label in bboxes:
                 cat_id = class_mapping[label.obj_class.name]
                 coco_obj = coco_obj_template(label_id, coco_image_id, cat_id)
@@ -713,7 +767,9 @@ def sly_ds_to_coco(
 
         coco_ann["images"].append(image_coco(image_info, image_idx))
         if with_captions is True:
-            coco_captions["images"].append(image_coco(image_info, image_idx))  # pylint: disable=unsubscriptable-object
+            # pylint: disable=unsubscriptable-object
+            coco_captions["images"].append(image_coco(image_info, image_idx))
+            # pylint: enable=unsubscriptable-object
 
         ann = Annotation.load_json_file(ann_path, meta)
         if ann.img_size is None or ann.img_size == (0, 0) or ann.img_size == (None, None):
@@ -815,3 +871,97 @@ def sly_project_to_coco(
         )
         logger.info(f"Dataset '{ds.short_name}' has been converted to COCO format.")
     logger.info(f"Project '{project.name}' has been converted to COCO format.")
+
+
+def to_coco(
+    input_data: Union[Project, Dataset, str],
+    dest_dir: Optional[str] = None,
+    meta: Optional[ProjectMeta] = None,
+    copy_images: bool = True,
+    with_captions: bool = False,
+    log_progress: bool = True,
+    progress_cb: Optional[Callable] = None,
+) -> Union[None, str]:
+    """
+    Universal function to convert Supervisely project or dataset to COCO format.
+    Note:
+        - For better compatibility, please pass named arguments explicitly. Otherwise, the function may not work as expected.
+            You can use the dedicated functions for each data type:
+
+                - :func:`sly.convert.sly_project_to_coco()`
+                - :func:`sly.convert.sly_ds_to_coco()`
+
+        - If the input_data is a Project, the dest_dir parameters are required.
+        - If the input_data is a Dataset, the meta and dest_dir parameters are required.
+
+    :param input_data: Supervisely project, dataset, or path to the project or dataset.
+    :type input_data: :class:`Project<supervisely.project.project.Project>`, :class:`Dataset<supervisely.project.dataset.Dataset>` or :class:`str`
+
+    # Project or Dataset conversion arguments:
+    :param dest_dir: Destination directory to save project or dataset in COCO format.
+    :type dest_dir: :class:`str`, optional
+    :param meta: Project meta information (required for dataset conversion).
+    :type meta: :class:`ProjectMeta<supervisely.project.project_meta.ProjectMeta>`, optional
+    :param copy_images: Copy images to destination directory
+    :type copy_images: :class:`bool`, optional
+    :param with_captions: If True, returns COCO captions
+    :type with_captions: :class:`bool`, optional
+    :param log_progress: Show uploading progress bar
+    :type log_progress: :class:`bool`
+    :param progress_cb: Function for tracking conversion progress (for all items in the project or dataset).
+    :type progress_cb: callable, optional
+
+    :return: None
+    :rtype: NoneType
+
+    :Usage example:
+
+    .. code-block:: python
+
+        import supervisely as sly
+
+        # Local folder with Project in Supervisely format
+        project_directory = "./source/project"
+        project_fs = sly.Project(project_directory, sly.OpenMode.READ)
+
+        # Convert Project to COCO format
+        sly.convert.to_coco(project_directory, dest_dir="./coco")
+        # or
+        sly.convert.to_coco(project_fs, dest_dir="./coco")
+
+        # Convert Dataset to COCO format
+        # dataset: sly.Dataset
+        sly.convert.to_coco(dataset, dest_dir="./coco", meta=project_fs.meta)
+    """
+    if isinstance(input_data, str):
+        try:
+            input_data = Project(input_data, mode=OpenMode.READ)
+        except Exception:
+            try:
+                input_data = Dataset(input_data, mode=OpenMode.READ)
+            except Exception:
+                raise ValueError("Please check the path or the input data.")
+
+    if isinstance(input_data, Project):
+        return sly_project_to_coco(
+            project=input_data,
+            dest_dir=dest_dir,
+            copy_images=copy_images,
+            with_captions=with_captions,
+            log_progress=log_progress,
+            progress_cb=progress_cb,
+        )
+    if isinstance(input_data, Dataset):
+        if meta is None:
+            raise ValueError("Project meta information is required for dataset conversion.")
+        return sly_ds_to_coco(
+            dataset=input_data,
+            meta=meta,
+            return_type="path",
+            dest_dir=dest_dir,
+            copy_images=copy_images,
+            with_captions=with_captions,
+            log_progress=log_progress,
+            progress_cb=progress_cb,
+        )
+    raise ValueError("Unsupported input type. Only Project or Dataset are supported.")