supervisely 6.73.298__py3-none-any.whl → 6.73.300__py3-none-any.whl

supervisely/nn/experiments.py

@@ -2,7 +2,7 @@ from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, fields
 from json import JSONDecodeError
 from os.path import dirname, join
-from typing import List
+from typing import List, Optional
 
 import requests
 
@@ -26,33 +26,39 @@ class ExperimentInfo:
     """Task ID in Supervisely"""
     model_files: dict
     """Dictionary with paths to model files that needs to be downloaded for training"""
+    model_meta: str
+    """Path to file with model metadata such as model name, project id, project name and classes used for training"""
     checkpoints: List[str]
     """List of relative paths to checkpoints"""
     best_checkpoint: str
     """Name of the best checkpoint. Defined by the user in the training app"""
-    export: dict
-    """Dictionary with exported weights in different formats"""
-    app_state: str
-    """Path to file with settings that were used in the app"""
-    model_meta: str
-    """Path to file with model metadata such as model name, project id, project name and classes used for training"""
-    train_val_split: str
-    """Path to train and validation splits, which contains IDs of the images used in each split"""
     hyperparameters: str
     """Path to .yaml file with hyperparameters used in the experiment"""
     artifacts_dir: str
     """Path to the directory with artifacts"""
-    datetime: str
+    export: Optional[dict] = None
+    """Dictionary with exported weights in different formats"""
+    app_state: Optional[str] = None
+    """Path to file with settings that were used in the app"""
+    train_val_split: Optional[str] = None
+    """Path to train and validation splits, which contains IDs of the images used in each split"""
+    train_size: Optional[int] = None
+    """Number of images in the training set"""
+    val_size: Optional[int] = None
+    """Number of images in the validation set"""
+    datetime: Optional[str] = None
     """Date and time when the experiment was started"""
-    evaluation_report_id: int
-    """ID of the evaluation report"""
-    evaluation_metrics: dict
+    evaluation_report_id: Optional[int] = None
+    """ID of the model benchmark evaluation report"""
+    evaluation_report_link: Optional[str] = None
+    """Link to the model benchmark evaluation report"""
+    evaluation_metrics: Optional[dict] = None
     """Evaluation metrics"""
+    logs: Optional[dict] = None
+    """Dictionary with link and type of logger"""
 
 
-def get_experiment_infos(
-    api: Api, team_id: int, framework_name: str
-) -> List[ExperimentInfo]:
+def get_experiment_infos(api: Api, team_id: int, framework_name: str) -> List[ExperimentInfo]:
     """
     Get experiments from the specified framework folder for Train v2
 
@@ -79,9 +85,7 @@ def get_experiment_infos(
     experiments_folder = "/experiments"
     experiment_infos = []
 
-    file_infos = api.file.list(
-        team_id, experiments_folder, recursive=True, return_type="fileinfo"
-    )
+    file_infos = api.file.list(team_id, experiments_folder, recursive=True, return_type="fileinfo")
     sorted_experiment_paths = []
     for file_info in file_infos:
         if not file_info.path.endswith(metadata_name):
@@ -101,11 +105,25 @@ def get_experiment_infos(
             )
             response.raise_for_status()
             response_json = response.json()
-            required_fields = {field.name for field in fields(ExperimentInfo)}
-            missing_fields = required_fields - response_json.keys()
-            if missing_fields:
+            required_fields = {
+                field.name for field in fields(ExperimentInfo) if field.default is not None
+            }
+            optional_fields = {
+                field.name for field in fields(ExperimentInfo) if field.default is None
+            }
+
+            missing_optional_fields = optional_fields - response_json.keys()
+            if missing_optional_fields:
+                logger.debug(
+                    f"Missing optional fields: {missing_optional_fields} for '{experiment_path}'"
+                )
+                for field in missing_optional_fields:
+                    response_json[field] = None
+
+            missing_required_fields = required_fields - response_json.keys()
+            if missing_required_fields:
                 logger.debug(
-                    f"Missing fields: {missing_fields} for '{experiment_path}'"
+                    f"Missing required fields: {missing_required_fields} for '{experiment_path}'. Skipping."
                 )
                 return None
             return ExperimentInfo(**response_json)
@@ -118,9 +136,7 @@ def get_experiment_infos(
         return None
 
     with ThreadPoolExecutor() as executor:
-        experiment_infos = list(
-            executor.map(fetch_experiment_data, sorted_experiment_paths)
-        )
+        experiment_infos = list(executor.map(fetch_experiment_data, sorted_experiment_paths))
 
     experiment_infos = [info for info in experiment_infos if info is not None]
     return experiment_infos

supervisely/nn/inference/inference.py

@@ -670,6 +670,56 @@ class Inference:
             self.update_gui(self._model_served)
             self.gui.show_deployed_model_info(self)
 
+    def load_custom_checkpoint(self, model_files: dict, model_meta: dict, device: str = "cuda"):
+        """
+        Loads local custom model checkpoint.
+
+        :param: model_files: dict with paths to model files
+        :type: model_files: dict
+        :param: model_meta: dict with model meta
+        :type: model_meta: dict
+        :param: device: device to load model on
+        :type: device: str
+        :return: None
+        :rtype: None
+
+        :Usage Example:
+
+         .. code-block:: python
+
+            model_files = {
+                "checkpoint": "supervisely_integration/serve/best.pth",
+                "config": "supervisely_integration/serve/model_config.yml",
+            }
+            model_meta = sly.json.load_json_file("model_meta.json")
+
+            model.load_custom_checkpoint(model_files, model_meta)
+        """
+
+        checkpoint = model_files.get("checkpoint")
+        if checkpoint is None:
+            raise ValueError("Model checkpoint is not provided")
+        checkpoint_name = sly_fs.get_file_name_with_ext(model_files["checkpoint"])
+
+        self.checkpoint_info = CheckpointInfo(
+            checkpoint_name=checkpoint_name,
+            model_name=None,
+            architecture=None,
+            checkpoint_url=None,
+            custom_checkpoint_path=None,
+            model_source=ModelSource.CUSTOM,
+        )
+
+        deploy_params = {
+            "model_source": ModelSource.CUSTOM,
+            "model_files": model_files,
+            "model_info": {},
+            "device": device,
+            "runtime": RuntimeType.PYTORCH,
+        }
+        self._set_model_meta_custom_model({"model_meta": model_meta})
+        self._load_model(deploy_params)
+
     def _load_model_headless(
         self,
         model_files: dict,
@@ -959,6 +1009,47 @@ class Inference:
         else:
             return self._inference_one_by_one_wrapper(source, settings)
 
+    def inference(
+        self,
+        source: Union[str, int, np.ndarray, List[str], List[int], List[np.ndarray]],
+        settings: dict = None,
+    ) -> Union[Annotation, List[Annotation], dict, List[dict]]:
+        """
+        Inference method for images. Provide image path or numpy array of image.
+
+        :param: source: image path,image id, numpy array of image or list of image paths, image ids or numpy arrays
+        :type: source: Union[str, int, np.ndarray, List[str], List[int], List[np.ndarray]]
+        :param: settings: inference settings
+        :type: settings: dict
+        :return: annotation or list of annotations
+        :rtype: Union[Annotation, List[Annotation], dict, List[dict]]
+
+        :Usage Example:
+
+            .. code-block:: python
+
+            image_path = "/root/projects/demo/img/sample.jpg"
+            ann = model.inference(image_path)
+        """
+        input_is_list = True
+        if not isinstance(source, list):
+            input_is_list = False
+            source = [source]
+
+        if settings is None:
+            settings = self._get_inference_settings({})
+
+        if isinstance(source[0], int):
+            ann_jsons = self._inference_batch_ids(
+                self.api, {"batch_ids": source, "settings": settings}
+            )
+            anns = [Annotation.from_json(ann_json, self.model_meta) for ann_json in ann_jsons]
+        else:
+            anns, _ = self._inference_auto(source, settings)
+        if not input_is_list:
+            return anns[0]
+        return anns
+
     def _inference_batched_wrapper(
         self,
         source: List[Union[str, np.ndarray]],

supervisely/nn/training/gui/training_artifacts.py

@@ -2,7 +2,8 @@ import os
 from typing import Any, Dict
 
 import supervisely.io.env as sly_env
-from supervisely import Api
+import supervisely.nn.training.gui.utils as gui_utils
+from supervisely import Api, logger
 from supervisely._utils import is_production
 from supervisely.api.api import ApiField
 from supervisely.app.widgets import (
@@ -37,7 +38,7 @@ class TrainingArtifacts:
         self.success_message_text = (
             "Training completed. Training artifacts were uploaded to Team Files. "
             "You can find and open tensorboard logs in the artifacts folder via the "
-            "<a href='https://ecosystem.supervisely.com/apps/tensorboard-logs-viewer' target='_blank'>Tensorboard</a> app."
+            "<a href='https://ecosystem.supervisely.com/apps/tensorboard-experiments-viewer' target='_blank'>Tensorboard Experiment Viewer</a> app."
         )
         self.app_options = app_options
 
@@ -90,6 +91,9 @@ class TrainingArtifacts:
             model_demo_path = model_demo.get("path", None)
             if model_demo_path is not None:
                 model_demo_gh_link = None
+                self.pytorch_instruction = None
+                self.onnx_instruction = None
+                self.trt_instruction = None
                 if is_production():
                     task_id = sly_env.task_id()
                     task_info = api.task.get_info_by_id(task_id)
@@ -98,15 +102,13 @@ class TrainingArtifacts:
                     model_demo_gh_link = app_info.repo
                 else:
                     app_name = sly_env.app_name()
-                    team_id = sly_env.team_id()
-                    apps = api.app.get_list(
-                        team_id,
-                        filter=[{"field": "name", "operator": "=", "value": app_name}],
-                        only_running=False,
-                    )
-                    if len(apps) == 1:
-                        app_info = apps[0]
-                        model_demo_gh_link = app_info.repo
+                    module_info = gui_utils.get_module_info_by_name(api, app_name)
+                    if module_info is not None:
+                        model_demo_gh_link = module_info["repo"]
+                    else:
+                        logger.warning(
+                            f"App '{app_name}' not found in Supervisely Ecosystem. Demo artifacts will not be displayed."
+                        )
 
                 if model_demo_gh_link is not None:
                     gh_branch = "blob/main"

supervisely/nn/training/gui/training_logs.py

@@ -1,9 +1,18 @@
 from typing import Any, Dict
 
-from supervisely import Api
+import supervisely.io.env as sly_env
+import supervisely.nn.training.gui.utils as gui_utils
+from supervisely import Api, logger
 from supervisely._utils import is_production
-from supervisely.app.widgets import Button, Card, Container, Progress, TaskLogs, Text
-from supervisely.io.env import task_id as get_task_id
+from supervisely.app.widgets import (
+    Button,
+    Card,
+    Container,
+    Progress,
+    RunAppButton,
+    TaskLogs,
+    Text,
+)
 
 
 class TrainingLogs:
@@ -21,7 +30,7 @@ class TrainingLogs:
         self.validator_text.hide()
 
         if is_production():
-            task_id = get_task_id(raise_not_found=False)
+            task_id = sly_env.task_id(raise_not_found=False)
         else:
             task_id = None
 
@@ -39,11 +48,36 @@ class TrainingLogs:
             plain=True,
             icon="zmdi zmdi-chart",
             link=self.tensorboard_link,
+            visible_by_vue_field="!isStaticVersion",
         )
         self.tensorboard_button.disable()
-
         self.display_widgets.extend([self.validator_text, self.tensorboard_button])
 
+        # Offline session Tensorboard button
+        self.tensorboard_offline_button = None
+        if is_production():
+            workspace_id = sly_env.workspace_id()
+            app_name = "Tensorboard Experiments Viewer"
+            module_info = gui_utils.get_module_info_by_name(api, app_name)
+            if module_info is not None:
+                self.tensorboard_offline_button = RunAppButton(
+                    workspace_id=workspace_id,
+                    module_id=module_info["id"],
+                    payload={},
+                    text="Open Tensorboard",
+                    button_type="info",
+                    plain=True,
+                    icon="zmdi zmdi-chart",
+                    available_in_offline=True,
+                    visible_by_vue_field="isStaticVersion",
+                )
+                self.tensorboard_offline_button.disable()
+                self.display_widgets.extend([self.tensorboard_offline_button])
+            else:
+                logger.warning(
+                    f"App '{app_name}' not found. Tensorboard button will not be displayed in offline mode."
+                )
+
         # Optional Show logs button
         if app_options.get("show_logs_in_gui", False):
             self.logs_button = Button(

supervisely/nn/training/gui/utils.py

@@ -1,5 +1,7 @@
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
+from supervisely import Api
+from supervisely.api.app_api import AppInfo
 from supervisely.app import DataJson
 from supervisely.app.widgets import Button, Card, Stepper, Text, Widget
 
@@ -126,3 +128,11 @@ def set_stepper_step(stepper: Stepper, button: Button, next_pos: int):
         stepper.set_active_step(next_pos)
     else:
         stepper.set_active_step(next_pos - 1)
+
+
+def get_module_info_by_name(api: Api, app_name: str) -> Union[Dict, None]:
+    all_modules = api.app.get_list_ecosystem_modules()
+    for module in all_modules:
+        if module["name"] == app_name:
+            app_info = api.app.get_info(module["id"])
+            return app_info

supervisely/nn/training/train_app.py

@@ -39,7 +39,7 @@ from supervisely import (
     is_production,
     logger,
 )
-from supervisely._utils import get_filename_from_headers
+from supervisely._utils import abs_url, get_filename_from_headers
 from supervisely.api.file_api import FileInfo
 from supervisely.app import get_synced_data_dir
 from supervisely.app.widgets import Progress
@@ -76,11 +76,11 @@ class TrainApp:
     :param framework_name: Name of the ML framework used.
     :type framework_name: str
     :param models: List of model configurations.
-    :type models: List[Dict[str, Any]]
+    :type models: Union[str, List[Dict[str, Any]]]
     :param hyperparameters: Path or string content of hyperparameters in YAML format.
     :type hyperparameters: str
     :param app_options: Options for the application layout and behavior.
-    :type app_options: Optional[Dict[str, Any]]
+    :type app_options: Optional[Union[str, Dict[str, Any]]]
     :param work_dir: Path to the working directory for storing intermediate files.
     :type work_dir: Optional[str]
     """
@@ -90,8 +90,8 @@ class TrainApp:
         framework_name: str,
         models: Union[str, List[Dict[str, Any]]],
         hyperparameters: str,
-        app_options: Union[str, Dict[str, Any]] = None,
-        work_dir: str = None,
+        app_options: Optional[Union[str, Dict[str, Any]]] = None,
+        work_dir: Optional[str] = None,
     ):
 
         # Init
@@ -120,6 +120,8 @@ class TrainApp:
             self.task_id = sly_env.task_id()
         else:
             self._app_name = sly_env.app_name(raise_not_found=False)
+            if self._app_name is None:
+                self._app_name = "custom-app"
             self.task_id = sly_env.task_id(raise_not_found=False)
             if self.task_id is None:
                 self.task_id = "debug-session"
@@ -526,6 +528,7 @@ class TrainApp:
         # Step 7. [Optional] Run Model Benchmark
         mb_eval_lnk_file_info, mb_eval_report = None, None
         mb_eval_report_id, eval_metrics = None, {}
+        evaluation_report_link, primary_metric_name = None, None
         if self.is_model_benchmark_enabled:
             try:
                 # Convert GT project
@@ -543,6 +546,7 @@ class TrainApp:
                     mb_eval_report,
                     mb_eval_report_id,
                     eval_metrics,
+                    primary_metric_name,
                 ) = self._run_model_benchmark(
                     self.output_dir,
                     remote_dir,
@@ -551,6 +555,7 @@ class TrainApp:
                     model_meta,
                     gt_project_id,
                 )
+                evaluation_report_link = abs_url(f"/model-benchmark?id={str(mb_eval_report_id)}")
             except Exception as e:
                 logger.error(f"Model benchmark failed: {e}")
 
@@ -565,18 +570,24 @@ class TrainApp:
 
         # Step 9. Generate and upload additional files
         self._set_text_status("metadata")
-        self._generate_experiment_info(
-            remote_dir, experiment_info, eval_metrics, mb_eval_report_id, export_weights
+        experiment_info = self._generate_experiment_info(
+            remote_dir,
+            experiment_info,
+            eval_metrics,
+            mb_eval_report_id,
+            evaluation_report_link,
+            primary_metric_name,
+            export_weights,
         )
         self._generate_app_state(remote_dir, experiment_info)
-        self._generate_hyperparameters(remote_dir, experiment_info)
+        experiment_info = self._generate_hyperparameters(remote_dir, experiment_info)
         self._generate_train_val_splits(remote_dir, train_splits_data)
         self._generate_model_meta(remote_dir, model_meta)
         self._upload_demo_files(remote_dir)
 
         # Step 10. Set output widgets
         self._set_text_status("reset")
-        self._set_training_output(remote_dir, file_info, mb_eval_report)
+        self._set_training_output(experiment_info, remote_dir, file_info, mb_eval_report)
         self._set_ws_progress_status("completed")
 
         # Step 11. Workflow output
@@ -1378,7 +1389,9 @@ class TrainApp:
         return experiment_info
 
     # Generate experiment_info.json and app_state.json
-    def _upload_file_to_team_files(self, local_path: str, remote_path: str, message: str) -> None:
+    def _upload_file_to_team_files(
+        self, local_path: str, remote_path: str, message: str
+    ) -> Union[FileInfo, None]:
         """Helper function to upload a file with progress."""
         logger.debug(f"Uploading '{local_path}' to Supervisely")
         total_size = sly_fs.get_file_size(local_path)
@@ -1386,13 +1399,14 @@ class TrainApp:
             message=message, total=total_size, unit="bytes", unit_scale=True
         ) as upload_artifacts_pbar:
             self.progress_bar_main.show()
-            self._api.file.upload(
+            file_info = self._api.file.upload(
                 self.team_id,
                 local_path,
                 remote_path,
                 progress_cb=upload_artifacts_pbar,
             )
             self.progress_bar_main.hide()
+            return file_info
 
     def _generate_train_val_splits(self, remote_dir: str, splits_data: dict) -> None:
         """
@@ -1446,7 +1460,10 @@ class TrainApp:
 
         if task_type == TaskType.OBJECT_DETECTION:
             model_meta, _ = model_meta.to_detection_task(True)
-        elif task_type in [TaskType.INSTANCE_SEGMENTATION, TaskType.SEMANTIC_SEGMENTATION]:
+        elif task_type in [
+            TaskType.INSTANCE_SEGMENTATION,
+            TaskType.SEMANTIC_SEGMENTATION,
+        ]:
             model_meta, _ = model_meta.to_segmentation_task()  # @TODO: check background class
         return model_meta
 
@@ -1456,8 +1473,10 @@ class TrainApp:
         experiment_info: Dict,
         eval_metrics: Dict = {},
         evaluation_report_id: Optional[int] = None,
+        evaluation_report_link: Optional[str] = None,
+        primary_metric_name: str = None,
         export_weights: Dict = {},
-    ) -> None:
+    ) -> dict:
         """
         Generates and uploads the experiment_info.json file to the output directory.
 
@@ -1469,6 +1488,8 @@ class TrainApp:
         :type eval_metrics: dict
         :param evaluation_report_id: Evaluation report file ID.
         :type evaluation_report_id: int
+        :param evaluation_report_link: Evaluation report file link.
+        :type evaluation_report_link: str
         :param export_weights: Export data.
         :type export_weights: dict
         """
@@ -1488,11 +1509,15 @@ class TrainApp:
             "app_state": self._app_state_file,
             "model_meta": self._model_meta_file,
             "train_val_split": self._train_val_split_file,
+            "train_size": len(self._train_split),
+            "val_size": len(self._val_split),
             "hyperparameters": self._hyperparameters_file,
             "artifacts_dir": remote_dir,
             "datetime": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             "evaluation_report_id": evaluation_report_id,
+            "evaluation_report_link": evaluation_report_link,
             "evaluation_metrics": eval_metrics,
+            "logs": {"type": "tensorboard", "link": f"{remote_dir}logs/"},
         }
 
         remote_checkpoints_dir = join(remote_dir, self._remote_checkpoints_dir_name)
@@ -1519,6 +1544,10 @@ class TrainApp:
             f"Uploading '{self._experiment_json_file}' to Team Files",
         )
 
+        # Do not include this fields to uploaded file:
+        experiment_info["primary_metric"] = primary_metric_name
+        return experiment_info
+
     def _generate_hyperparameters(self, remote_dir: str, experiment_info: Dict) -> None:
         """
         Generates and uploads the hyperparameters.yaml file to the output directory.
@@ -1534,11 +1563,13 @@ class TrainApp:
         with open(local_path, "w") as file:
             file.write(self.hyperparameters_yaml)
 
-        self._upload_file_to_team_files(
+        file_info = self._upload_file_to_team_files(
             local_path,
             remote_path,
             f"Uploading '{self._hyperparameters_file}' to Team Files",
         )
+        experiment_info["hyperparameters_id"] = file_info.id
+        return experiment_info
 
     def _generate_app_state(self, remote_dir: str, experiment_info: Dict) -> None:
         """
@@ -1702,10 +1733,20 @@ class TrainApp:
             self.progress_bar_main.hide()
 
         file_info = self._api.file.get_info_by_path(self.team_id, join(remote_dir, "open_app.lnk"))
+        # Set offline tensorboard button payload
+        if is_production():
+            self.gui.training_logs.tensorboard_offline_button.payload = {
+                "state": {"slyFolder": f"{join(remote_dir, 'logs')}"}
+            }
+            self.gui.training_logs.tensorboard_offline_button.enable()
         return remote_dir, file_info
 
     def _set_training_output(
-        self, remote_dir: str, file_info: FileInfo, mb_eval_report=None
+        self,
+        experiment_info: dict,
+        remote_dir: str,
+        file_info: FileInfo,
+        mb_eval_report=None,
     ) -> None:
         """
         Sets the training output in the GUI.
@@ -1718,6 +1759,7 @@ class TrainApp:
         # self.gui.training_logs.tensorboard_button.disable()
 
         # Set artifacts to GUI
+        self._api.task.set_output_experiment(self.task_id, experiment_info)
         set_directory(remote_dir)
         self.gui.training_artifacts.artifacts_thumbnail.set(file_info)
         self.gui.training_artifacts.artifacts_thumbnail.show()
@@ -1742,13 +1784,15 @@ class TrainApp:
         if demo_path is not None:
             # Show PyTorch demo if available
             if self.gui.training_artifacts.pytorch_demo_exists(demo_path):
-                self.gui.training_artifacts.pytorch_instruction.show()
+                if self.gui.training_artifacts.pytorch_instruction is not None:
+                    self.gui.training_artifacts.pytorch_instruction.show()
 
             # Show ONNX demo if supported and available
             if (
                 self._app_options.get("export_onnx_supported", False)
                 and self.gui.hyperparameters_selector.get_export_onnx_checkbox_value()
                 and self.gui.training_artifacts.onnx_demo_exists(demo_path)
+                and self.gui.training_artifacts.onnx_instruction is not None
             ):
                 self.gui.training_artifacts.onnx_instruction.show()
 
@@ -1757,6 +1801,7 @@ class TrainApp:
                 self._app_options.get("export_tensorrt_supported", False)
                 and self.gui.hyperparameters_selector.get_export_tensorrt_checkbox_value()
                 and self.gui.training_artifacts.trt_demo_exists(demo_path)
+                and self.gui.training_artifacts.trt_instruction is not None
             ):
                 self.gui.training_artifacts.trt_instruction.show()
 
@@ -1983,6 +2028,8 @@ class TrainApp:
             report = bm.report
             report_id = bm.report.id
             eval_metrics = bm.key_metrics
+            primary_metric_name = bm.primary_metric_name
+            bm.upload_report_link(remote_artifacts_dir, report_id, self.output_dir)
 
             # 8. UI updates
             self.progress_bar_main.hide()
@@ -1991,6 +2038,7 @@ class TrainApp:
             logger.info(
                 f"Predictions project name: {bm.dt_project_info.name}. Workspace_id: {bm.dt_project_info.workspace_id}"
             )
+
         except Exception as e:
             logger.error(f"Model benchmark failed. {repr(e)}", exc_info=True)
             self._set_text_status("finalizing")
@@ -2004,7 +2052,7 @@ class TrainApp:
                     self._api.project.remove(diff_project_info.id)
             except Exception as e2:
                 return lnk_file_info, report, report_id, eval_metrics
-        return lnk_file_info, report, report_id, eval_metrics
+        return lnk_file_info, report, report_id, eval_metrics, primary_metric_name
 
     # ----------------------------------------- #
 
@@ -2476,7 +2524,11 @@ class TrainApp:
     def _convert_and_split_gt_project(self, task_type: str):
         # 1. Convert GT project to cv task
         Project.download(
-            self._api, self.project_info.id, "tmp_project", save_images=False, save_image_info=True
+            self._api,
+            self.project_info.id,
+            "tmp_project",
+            save_images=False,
+            save_image_info=True,
         )
         project = Project("tmp_project", OpenMode.READ)
 

{supervisely-6.73.298.dist-info → supervisely-6.73.300.dist-info}/METADATA

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