supervisely 6.73.269__py3-none-any.whl → 6.73.271__py3-none-any.whl

supervisely/api/file_api.py

@@ -1620,7 +1620,7 @@ class FileApi(ModuleApiBase):
                 downloaded_file_hash = await get_file_hash_async(local_save_path)
                 if hash_to_check != downloaded_file_hash:
                     raise RuntimeError(
-                        f"Downloaded hash of image with ID:{id} does not match the expected hash: {downloaded_file_hash} != {hash_to_check}"
+                        f"Downloaded hash of file path: '{remote_path}' does not match the expected hash: {downloaded_file_hash} != {hash_to_check}"
                     )
         if progress_cb is not None and progress_cb_type == "number":
             progress_cb(1)

supervisely/nn/inference/inference.py

@@ -1,3 +1,5 @@
+import argparse
+import asyncio
 import inspect
 import json
 import os
@@ -11,12 +13,14 @@ from collections import OrderedDict, defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import asdict
 from functools import partial, wraps
+from pathlib import Path
 from queue import Queue
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 from urllib.request import urlopen
 
 import numpy as np
 import requests
+import uvicorn
 import yaml
 from fastapi import Form, HTTPException, Request, Response, UploadFile, status
 from fastapi.responses import JSONResponse
@@ -24,8 +28,7 @@ from requests.structures import CaseInsensitiveDict
 
 import supervisely.app.development as sly_app_development
 import supervisely.imaging.image as sly_image
-import supervisely.io.env as env
-import supervisely.io.fs as fs
+import supervisely.io.env as sly_env
 import supervisely.io.fs as sly_fs
 import supervisely.io.json as sly_json
 import supervisely.nn.inference.gui as GUI
@@ -33,6 +36,7 @@ from supervisely import DatasetInfo, ProjectInfo, VideoAnnotation, batched
 from supervisely._utils import (
     add_callback,
     get_filename_from_headers,
+    get_or_create_event_loop,
     is_debug_with_sly_net,
     is_production,
     rand_str,
@@ -43,6 +47,7 @@ from supervisely.annotation.obj_class import ObjClass
 from supervisely.annotation.tag_collection import TagCollection
 from supervisely.annotation.tag_meta import TagMeta, TagValueType
 from supervisely.api.api import Api
+from supervisely.api.app_api import WorkflowMeta, WorkflowSettings
 from supervisely.api.image_api import ImageInfo
 from supervisely.app.content import StateJson, get_data_dir
 from supervisely.app.exceptions import DialogWindowError
@@ -106,9 +111,19 @@ class Inference:
         multithread_inference: Optional[bool] = True,
         use_serving_gui_template: Optional[bool] = False,
     ):
+
+        self._args, self._is_local_deploy = self._parse_local_deploy_args()
+
         if model_dir is None:
-            model_dir = os.path.join(get_data_dir(), "models")
-            fs.mkdir(model_dir)
+            if self._is_local_deploy is True:
+                try:
+                    model_dir = get_data_dir()
+                except:
+                    model_dir = Path("~/.cache/supervisely/app_data").expanduser()
+            else:
+                model_dir = os.path.join(get_data_dir(), "models")
+        sly_fs.mkdir(model_dir)
+
         self.device: str = None
         self.runtime: str = None
         self.model_precision: str = None
@@ -128,7 +143,7 @@ class Inference:
         self._autostart_delay_time = 5 * 60  # 5 min
         self._tracker = None
         self._hardware: str = None
-        self.pretrained_models = self._load_models_json(self.MODELS) if self.MODELS else None
+        self.pretrained_models = self._load_models_json_file(self.MODELS) if self.MODELS else None
         if custom_inference_settings is None:
             if self.INFERENCE_SETTINGS is not None:
                 custom_inference_settings = self.INFERENCE_SETTINGS
@@ -136,7 +151,7 @@ class Inference:
                 logger.debug("Custom inference settings are not provided.")
                 custom_inference_settings = {}
         if isinstance(custom_inference_settings, str):
-            if fs.file_exists(custom_inference_settings):
+            if sly_fs.file_exists(custom_inference_settings):
                 with open(custom_inference_settings, "r") as f:
                     custom_inference_settings = f.read()
             else:
@@ -146,12 +161,24 @@ class Inference:
         self._use_gui = use_gui
         self._use_serving_gui_template = use_serving_gui_template
         self._gui = None
+        self._uvicorn_server = None
 
         self.load_on_device = LOAD_ON_DEVICE_DECORATOR(self.load_on_device)
         self.load_on_device = add_callback(self.load_on_device, self._set_served_callback)
 
         self.load_model = LOAD_MODEL_DECORATOR(self.load_model)
 
+        if self._is_local_deploy:
+            # self._args = self._parse_local_deploy_args()
+            self._use_gui = False
+            deploy_params, need_download = self._get_deploy_params_from_args()
+            if need_download:
+                local_model_files = self._download_model_files(
+                    deploy_params["model_source"], deploy_params["model_files"], False
+                )
+                deploy_params["model_files"] = local_model_files
+            self._load_model_headless(**deploy_params)
+
         if self._use_gui:
             initialize_custom_gui_method = getattr(self, "initialize_custom_gui", None)
             original_initialize_custom_gui_method = getattr(
@@ -224,10 +251,10 @@ class Inference:
         self.get_info = self._check_serve_before_call(self.get_info)
 
         self.cache = InferenceImageCache(
-            maxsize=env.smart_cache_size(),
-            ttl=env.smart_cache_ttl(),
+            maxsize=sly_env.smart_cache_size(),
+            ttl=sly_env.smart_cache_ttl(),
             is_persistent=True,
-            base_folder=env.smart_cache_container_dir(),
+            base_folder=sly_env.smart_cache_container_dir(),
             log_progress=True,
         )
 
@@ -248,9 +275,18 @@ class Inference:
                 )
                 device = "cpu"
 
-    def _load_models_json(self, models: str) -> List[Dict[str, Any]]:
+    def _load_json_file(self, file_path: str) -> dict:
+        if isinstance(file_path, str):
+            if sly_fs.file_exists(file_path) and sly_fs.get_file_ext(file_path) == ".json":
+                return sly_json.load_json_file(file_path)
+            else:
+                raise ValueError("File not found or invalid file format.")
+        else:
+            raise ValueError("Invalid file. Please provide a valid '.json' file.")
+
+    def _load_models_json_file(self, models: str) -> List[Dict[str, Any]]:
         """
-        Loads models from the provided file or list of model configurations.
+        Loads dictionary from the provided file.
         """
         if isinstance(models, str):
             if sly_fs.file_exists(models) and sly_fs.get_file_ext(models) == ".json":
@@ -258,9 +294,7 @@ class Inference:
             else:
                 raise ValueError("File not found or invalid file format.")
         else:
-            raise ValueError(
-                "Invalid models file. Please provide a valid '.json' file with list of model configurations."
-            )
+            raise ValueError("Invalid file. Please provide a valid '.json' file.")
 
         if not isinstance(models, list):
             raise ValueError("models parameters must be a list of dicts")
@@ -394,13 +428,13 @@ class Inference:
         else:
             progress = None
 
-        if fs.dir_exists(src_path) or fs.file_exists(
+        if sly_fs.dir_exists(src_path) or sly_fs.file_exists(
             src_path
         ):  # only during debug, has no effect in production
             dst_path = os.path.abspath(src_path)
             logger.info(f"File {dst_path} found.")
         elif src_path.startswith("/"):  # folder from Team Files
-            team_id = env.team_id()
+            team_id = sly_env.team_id()
 
             if src_path.endswith("/") and self.api.file.dir_exists(team_id, src_path):
 
@@ -436,7 +470,7 @@ class Inference:
                 def download_file(team_id, src_path, dst_path, progress_cb=None):
                     self.api.file.download(team_id, src_path, dst_path, progress_cb=progress_cb)
 
-                file_info = self.api.file.get_info_by_path(env.team_id(), src_path)
+                file_info = self.api.file.get_info_by_path(sly_env.team_id(), src_path)
                 if progress is None:
                     download_file(team_id, src_path, dst_path)
                 else:
@@ -451,8 +485,8 @@ class Inference:
                 logger.info(f"📥 File {basename} has been successfully downloaded from Team Files")
                 logger.info(f"File {basename} path: {dst_path}")
         else:  # external url
-            if not fs.dir_exists(os.path.dirname(dst_path)):
-                fs.mkdir(os.path.dirname(dst_path))
+            if not sly_fs.dir_exists(os.path.dirname(dst_path)):
+                sly_fs.mkdir(os.path.dirname(dst_path))
 
             def download_external_file(url, save_path, progress=None):
                 def download_content(save_path, progress_cb=None):
@@ -531,13 +565,15 @@ class Inference:
     def _checkpoints_cache_dir(self):
         return os.path.join(os.path.expanduser("~"), ".cache", "supervisely", "checkpoints")
 
-    def _download_model_files(self, model_source: str, model_files: List[str]) -> dict:
+    def _download_model_files(
+        self, model_source: str, model_files: List[str], log_progress: bool = True
+    ) -> dict:
         if model_source == ModelSource.PRETRAINED:
-            return self._download_pretrained_model(model_files)
+            return self._download_pretrained_model(model_files, log_progress)
         elif model_source == ModelSource.CUSTOM:
-            return self._download_custom_model(model_files)
+            return self._download_custom_model(model_files, log_progress)
 
-    def _download_pretrained_model(self, model_files: dict):
+    def _download_pretrained_model(self, model_files: dict, log_progress: bool = True):
         """
         Downloads the pretrained model data.
         """
@@ -564,54 +600,61 @@ class Inference:
                         logger.debug(f"Model: '{file_name}' was found in model dir")
                         continue
 
-                    with self.gui.download_progress(
-                        message=f"Downloading: '{file_name}'",
-                        total=file_size,
-                        unit="bytes",
-                        unit_scale=True,
-                    ) as download_pbar:
-                        self.gui.download_progress.show()
-                        sly_fs.download(
-                            url=file_url,
-                            save_path=file_path,
-                            progress=download_pbar.update,
-                        )
+                    if log_progress:
+                        with self.gui.download_progress(
+                            message=f"Downloading: '{file_name}'",
+                            total=file_size,
+                            unit="bytes",
+                            unit_scale=True,
+                        ) as download_pbar:
+                            self.gui.download_progress.show()
+                            sly_fs.download(
+                                url=file_url, save_path=file_path, progress=download_pbar.update
+                            )
+                    else:
+                        sly_fs.download(url=file_url, save_path=file_path)
                     local_model_files[file] = file_path
             else:
                 local_model_files[file] = file_url
-        self.gui.download_progress.hide()
+
+        if log_progress:
+            self.gui.download_progress.hide()
         return local_model_files
 
-    def _download_custom_model(self, model_files: dict):
+    def _download_custom_model(self, model_files: dict, log_progress: bool = True):
         """
         Downloads the custom model data.
         """
-
-        team_id = env.team_id()
+        team_id = sly_env.team_id()
         local_model_files = {}
-
         for file in model_files:
             file_url = model_files[file]
             file_info = self.api.file.get_info_by_path(team_id, file_url)
             if file_info is None:
-                raise FileNotFoundError(
-                    f"File '{file_url}' not found in Team Files. Make sure the file exists."
-                )
+                if sly_fs.file_exists(file_url):
+                    local_model_files[file] = file_url
+                    continue
+                else:
+                    raise FileNotFoundError(f"File '{file_url}' not found in Team Files")
             file_size = file_info.sizeb
             file_name = os.path.basename(file_url)
             file_path = os.path.join(self.model_dir, file_name)
-            with self.gui.download_progress(
-                message=f"Downloading: '{file_name}'",
-                total=file_size,
-                unit="bytes",
-                unit_scale=True,
-            ) as download_pbar:
-                self.gui.download_progress.show()
-                self.api.file.download(
-                    team_id, file_url, file_path, progress_cb=download_pbar.update
-                )
+            if log_progress:
+                with self.gui.download_progress(
+                    message=f"Downloading: '{file_name}'",
+                    total=file_size,
+                    unit="bytes",
+                    unit_scale=True,
+                ) as download_pbar:
+                    self.gui.download_progress.show()
+                    self.api.file.download(
+                        team_id, file_url, file_path, progress_cb=download_pbar.update
+                    )
+            else:
+                self.api.file.download(team_id, file_url, file_path)
             local_model_files[file] = file_path
-        self.gui.download_progress.hide()
+        if log_progress:
+            self.gui.download_progress.hide()
         return local_model_files
 
     def _load_model(self, deploy_params: dict):
@@ -647,6 +690,13 @@ class Inference:
         if model_source == ModelSource.CUSTOM:
             self._set_model_meta_custom_model(model_info)
             self._set_checkpoint_info_custom_model(deploy_params)
+
+        try:
+            if is_production():
+                self._add_workflow_input(model_source, model_files, model_info)
+        except Exception as e:
+            logger.warning(f"Failed to add input to the workflow: {repr(e)}")
+
         self._load_model(deploy_params)
         if self._model_meta is None:
             self._set_model_meta_from_classes()
@@ -679,7 +729,7 @@ class Inference:
                 model_info.get("artifacts_dir"), "checkpoints", checkpoint_name
             )
             checkpoint_file_info = self.api.file.get_info_by_path(
-                env.team_id(), checkpoint_file_path
+                sly_env.team_id(), checkpoint_file_path
             )
             if checkpoint_file_info is None:
                 checkpoint_url = None
@@ -1253,18 +1303,18 @@ class Inference:
         logger.debug("Inferring image_url...", extra={"state": state})
         settings = self._get_inference_settings(state)
         image_url = state["image_url"]
-        ext = fs.get_file_ext(image_url)
+        ext = sly_fs.get_file_ext(image_url)
         if ext == "":
             ext = ".jpg"
         image_path = os.path.join(get_data_dir(), rand_str(15) + ext)
-        fs.download(image_url, image_path)
+        sly_fs.download(image_url, image_path)
         logger.debug("Inference settings:", extra=settings)
         logger.debug(f"Downloaded path: {image_path}")
         anns, slides_data = self._inference_auto(
             [image_path],
             settings=settings,
         )
-        fs.silent_remove(image_path)
+        sly_fs.silent_remove(image_path)
         return self._format_output(anns, slides_data)[0]
 
     def _inference_video_id(self, api: Api, state: dict, async_inference_request_uuid: str = None):
@@ -2208,28 +2258,46 @@ class Inference:
 
         if is_debug_with_sly_net():
             # advanced debug for Supervisely Team
-            logger.warn(
+            logger.warning(
                 "Serving is running in advanced development mode with Supervisely VPN Network"
             )
-            team_id = env.team_id()
+            team_id = sly_env.team_id()
             # sly_app_development.supervisely_vpn_network(action="down") # for debug
             sly_app_development.supervisely_vpn_network(action="up")
             task = sly_app_development.create_debug_task(team_id, port="8000")
             self._task_id = task["id"]
             os.environ["TASK_ID"] = str(self._task_id)
         else:
-            self._task_id = env.task_id() if is_production() else None
+            if not self._is_local_deploy:
+                self._task_id = sly_env.task_id() if is_production() else None
 
         if isinstance(self.gui, GUI.InferenceGUI):
             self._app = Application(layout=self.get_ui())
         elif isinstance(self.gui, GUI.ServingGUI):
             self._app = Application(layout=self._app_layout)
+        # elif isinstance(self.gui, GUI.InferenceGUI):
+        #     self._app = Application(layout=self.get_ui())
         else:
             self._app = Application(layout=self.get_ui())
 
         server = self._app.get_server()
         self._app.set_ready_check_function(self.is_model_deployed)
 
+        if self._is_local_deploy:
+            # Predict and shutdown
+            if any(
+                [
+                    self._args.predict_project,
+                    self._args.predict_dataset,
+                    self._args.predict_dir,
+                    self._args.predict_image,
+                ]
+            ):
+                self._inference_by_local_deploy_args()
+                # Gracefully shut down the server
+                self._app.shutdown()
+        # else: run server after endpoints
+
         @call_on_autostart()
         def autostart_func():
             gpu_count = get_gpu_count()
@@ -2725,6 +2793,285 @@ class Inference:
         def _get_deploy_info():
             return asdict(self._get_deploy_info())
 
+        # Local deploy without predict args
+        if self._is_local_deploy:
+            self._run_server()
+
+    def _parse_local_deploy_args(self):
+        parser = argparse.ArgumentParser(description="Run Inference Serving")
+
+        # Deploy args
+        parser.add_argument(
+            "--model",
+            type=str,
+            help="Name of the pretrained model or path to custom checkpoint file",
+        )
+        parser.add_argument(
+            "--device",
+            type=str,
+            choices=["cpu", "cuda", "cuda:0", "cuda:1", "cuda:2", "cuda:3"],
+            default="cuda:0",
+            help="Device to use for inference (default: 'cuda:0')",
+        )
+        parser.add_argument(
+            "--runtime",
+            type=str,
+            choices=[RuntimeType.PYTORCH, RuntimeType.ONNXRUNTIME, RuntimeType.TENSORRT],
+            default=RuntimeType.PYTORCH,
+            help="Runtime type for inference (default: PYTORCH)",
+        )
+        # -------------------------- #
+
+        # Predict args
+        parser.add_argument("--predict-project", type=int, required=False, help="ID of the project")
+        parser.add_argument(
+            "--predict-dataset",
+            type=lambda x: [int(i) for i in x.split(",")] if "," in x else int(x),
+            required=False,
+            help="ID of the dataset or a comma-separated list of dataset IDs",
+        )
+        parser.add_argument(
+            "--predict-dir",
+            type=str,
+            required=False,
+            help="Not implemented yet. Path to the local directory with images",
+        )
+        parser.add_argument(
+            "--predict-image",
+            type=str,
+            required=False,
+            help="Image ID on Supervisely instance or path to local image",
+        )
+        # -------------------------- #
+
+        # Output args
+        parser.add_argument("--output", type=str, required=False, help="Not implemented yet")
+        parser.add_argument("--output-dir", type=str, required=False, help="Not implemented yet")
+        # -------------------------- #
+
+        # Parse arguments
+        args, _ = parser.parse_known_args()
+        if args.model is None:
+            # raise ValueError("Argument '--model' is required for local deployment")
+            return None, False
+        if isinstance(args.predict_dataset, int):
+            args.predict_dataset = [args.predict_dataset]
+        if args.predict_image is not None:
+            if args.predict_image.isdigit():
+                args.predict_image = int(args.predict_image)
+        return args, True
+
+    def _get_pretrained_model_params_from_args(self):
+        model_files = None
+        model_source = None
+        model_info = None
+        need_download = True
+
+        model = self._args.model
+        for m in self.pretrained_models:
+            meta = m.get("meta", None)
+            if meta is None:
+                continue
+            model_name = meta.get("model_name", None)
+            if model_name is None:
+                continue
+            m_files = meta.get("model_files", None)
+            if m_files is None:
+                continue
+            checkpoint = m_files.get("checkpoint", None)
+            if checkpoint is None:
+                continue
+            if model == m["meta"]["model_name"]:
+                model_info = m
+                model_source = ModelSource.PRETRAINED
+                model_files = {"checkpoint": checkpoint}
+                config = m_files.get("config", None)
+                if config is not None:
+                    model_files["config"] = config
+                break
+
+        return model_files, model_source, model_info, need_download
+
+    def _get_custom_model_params_from_args(self):
+        def _load_experiment_info(artifacts_dir):
+            experiment_path = os.path.join(artifacts_dir, "experiment_info.json")
+            model_info = self._load_json_file(experiment_path)
+            original_model_files = model_info.get("model_files")
+            if not original_model_files:
+                raise ValueError("Invalid 'experiment_info.json'. Missing 'model_files' key.")
+            return model_info, original_model_files
+
+        def _prepare_local_model_files(artifacts_dir, checkpoint_path, original_model_files):
+            return {k: os.path.join(artifacts_dir, v) for k, v in original_model_files.items()} | {
+                "checkpoint": checkpoint_path
+            }
+
+        def _download_remote_files(team_id, artifacts_dir, local_artifacts_dir):
+            sly_fs.mkdir(local_artifacts_dir, True)
+            file_infos = self.api.file.list(team_id, artifacts_dir, False, "fileinfo")
+            remote_paths = [f.path for f in file_infos if not f.is_dir]
+            local_paths = [
+                os.path.join(local_artifacts_dir, f.name) for f in file_infos if not f.is_dir
+            ]
+
+            coro = self.api.file.download_bulk_async(team_id, remote_paths, local_paths)
+            loop = get_or_create_event_loop()
+            if loop.is_running():
+                future = asyncio.run_coroutine_threadsafe(coro, loop)
+                future.result()
+            else:
+                loop.run_until_complete(coro)
+
+        model_source = ModelSource.CUSTOM
+        need_download = False
+        checkpoint_path = self._args.model
+
+        if not os.path.isfile(checkpoint_path):
+            team_id = sly_env.team_id(raise_not_found=False)
+            if not team_id:
+                raise ValueError(
+                    "Team ID not found in env. Required for remote custom checkpoints."
+                )
+            file_info = self.api.file.get_info_by_path(team_id, checkpoint_path)
+            if not file_info:
+                raise ValueError(
+                    f"Couldn't find: '{checkpoint_path}' locally or remotely in Team ID."
+                )
+            need_download = True
+
+        artifacts_dir = os.path.dirname(os.path.dirname(checkpoint_path))
+        if not need_download:
+            model_info, original_model_files = _load_experiment_info(artifacts_dir)
+            model_files = _prepare_local_model_files(
+                artifacts_dir, checkpoint_path, original_model_files
+            )
+        else:
+            local_artifacts_dir = os.path.join(
+                self.model_dir, "local_deploy", os.path.basename(artifacts_dir)
+            )
+            _download_remote_files(team_id, artifacts_dir, local_artifacts_dir)
+
+            model_info, original_model_files = _load_experiment_info(local_artifacts_dir)
+            model_files = _prepare_local_model_files(
+                local_artifacts_dir, checkpoint_path, original_model_files
+            )
+        return model_files, model_source, model_info, need_download
+
+    def _get_deploy_params_from_args(self):
+        # Ensure model directory exists
+        device = self._args.device if self._args.device else "cuda:0"
+        runtime = self._args.runtime if self._args.runtime else RuntimeType.PYTORCH
+
+        model_files, model_source, model_info, need_download = (
+            self._get_pretrained_model_params_from_args()
+        )
+        if model_source is None:
+            model_files, model_source, model_info, need_download = (
+                self._get_custom_model_params_from_args()
+            )
+
+        if model_source is None:
+            raise ValueError("Couldn't create 'model_source' from args")
+        if model_files is None:
+            raise ValueError("Couldn't create 'model_files' from args")
+        if model_info is None:
+            raise ValueError("Couldn't create 'model_info' from args")
+
+        deploy_params = {
+            "model_files": model_files,
+            "model_source": model_source,
+            "model_info": model_info,
+            "device": device,
+            "runtime": runtime,
+        }
+
+        logger.info(f"Deploy parameters: {deploy_params}")
+        return deploy_params, need_download
+
+    def _run_server(self):
+        config = uvicorn.Config(app=self._app, host="0.0.0.0", port=8000, ws="websockets")
+        self._uvicorn_server = uvicorn.Server(config)
+        self._uvicorn_server.run()
+
+    def _inference_by_local_deploy_args(self):
+        def predict_project_by_args(api: Api, project_id: int, dataset_ids: List[int] = None):
+            source_project = api.project.get_info_by_id(project_id)
+            workspace_id = source_project.workspace_id
+            output_project = api.project.create(
+                workspace_id, f"{source_project.name} predicted", change_name_if_conflict=True
+            )
+            results = self._inference_project_id(
+                api=self.api,
+                state={
+                    "projectId": project_id,
+                    "dataset_ids": dataset_ids,
+                    "output_project_id": output_project.id,
+                },
+            )
+
+        def predict_datasets_by_args(api: Api, dataset_ids: List[int]):
+            dataset_infos = [api.dataset.get_info_by_id(dataset_id) for dataset_id in dataset_ids]
+            project_ids = list(set([dataset_info.project_id for dataset_info in dataset_infos]))
+            if len(project_ids) > 1:
+                raise ValueError("All datasets should belong to the same project")
+            predict_project_by_args(api, project_ids[0], dataset_ids)
+
+        def predict_image_by_args(api: Api, image: Union[str, int]):
+            def predict_image_np(image_np):
+                settings = self._get_inference_settings({})
+                anns, _ = self._inference_auto([image_np], settings)
+                if len(anns) == 0:
+                    return Annotation(img_size=image_np.shape[:2])
+                ann = anns[0]
+                return ann
+
+            if isinstance(image, int):
+                image_np = api.image.download_np(image)
+                ann = predict_image_np(image_np)
+                api.annotation.upload_ann(image, ann)
+            elif isinstance(image, str):
+                if sly_fs.file_exists(self._args.predict):
+                    image_np = sly_image.read(self._args.predict)
+                    ann = predict_image_np(image_np)
+                    pred_ann_path = image + ".json"
+                    sly_json.dump_json_file(ann.to_json(), pred_ann_path)
+                    # Save image for debug
+                    # ann.draw_pretty(image_np)
+                    # pred_path = os.path.join(os.path.dirname(self._args.predict), "pred_" + os.path.basename(self._args.predict))
+                    # sly_image.write(pred_path, image_np)
+
+        if self._args.predict_project is not None:
+            predict_project_by_args(self.api, self._args.predict_project)
+        elif self._args.predict_dataset is not None:
+            predict_datasets_by_args(self.api, self._args.predict_dataset)
+        elif self._args.predict_dir is not None:
+            raise NotImplementedError("Predict from directory is not implemented yet")
+        elif self._args.predict_image is not None:
+            predict_image_by_args(self.api, self._args.predict_image)
+
+    def _add_workflow_input(self, model_source: str, model_files: dict, model_info: dict):
+        if model_source == ModelSource.PRETRAINED:
+            checkpoint_url = model_info["meta"]["model_files"]["checkpoint"]
+            checkpoint_name = model_info["meta"]["model_name"]
+        else:
+            checkpoint_name = sly_fs.get_file_name_with_ext(model_files["checkpoint"])
+            checkpoint_url = os.path.join(
+                model_info["artifacts_dir"], "checkpoints", checkpoint_name
+            )
+
+        app_name = sly_env.app_name()
+        meta = WorkflowMeta(node_settings=WorkflowSettings(title=f"Serve {app_name}"))
+
+        logger.debug(
+            f"Workflow Input: Checkpoint URL - {checkpoint_url}, Checkpoint Name - {checkpoint_name}"
+        )
+        if checkpoint_url and self.api.file.exists(sly_env.team_id(), checkpoint_url):
+            self.api.app.workflow.add_input_file(checkpoint_url, model_weight=True, meta=meta)
+        else:
+            logger.debug(
+                f"Checkpoint {checkpoint_url} not found in Team Files. Cannot set workflow input"
+            )
+
 
 def _get_log_extra_for_inference_request(inference_request_uuid, inference_request: dict):
     log_extra = {
@@ -2998,7 +3345,7 @@ class TempImageWriter:
     def __init__(self, format: str = "png"):
         self.format = format
         self.temp_dir = os.path.join(get_data_dir(), rand_str(10))
-        fs.mkdir(self.temp_dir)
+        sly_fs.mkdir(self.temp_dir)
 
     def write(self, image: np.ndarray):
         image_path = os.path.join(self.temp_dir, f"{rand_str(10)}.{self.format}")
@@ -3006,7 +3353,7 @@ class TempImageWriter:
         return image_path
 
     def clean(self):
-        fs.remove_dir(self.temp_dir)
+        sly_fs.remove_dir(self.temp_dir)
 
 
 def get_hardware_info(device: str) -> str:

supervisely/nn/training/gui/gui.py

@@ -5,6 +5,8 @@ This module provides the `TrainGUI` class that handles the graphical user interf
 training workflows in Supervisely.
 """
 
+from os import environ
+
 import supervisely.io.env as sly_env
 from supervisely import Api, ProjectMeta
 from supervisely._utils import is_production
@@ -47,7 +49,6 @@ class TrainGUI:
         app_options: dict = None,
     ):
         self._api = Api.from_env()
-
         if is_production():
             self.task_id = sly_env.task_id()
         else:
@@ -61,12 +62,19 @@ class TrainGUI:
         self.app_options = app_options
         self.collapsable = app_options.get("collapsable", False)
 
-        self.team_id = sly_env.team_id()
-        self.workspace_id = sly_env.workspace_id()
-        self.project_id = sly_env.project_id()  # from app options?
+        self.team_id = sly_env.team_id(raise_not_found=False)
+        self.workspace_id = sly_env.workspace_id(raise_not_found=False)
+        self.project_id = sly_env.project_id()
         self.project_info = self._api.project.get_info_by_id(self.project_id)
         self.project_meta = ProjectMeta.from_json(self._api.project.get_meta(self.project_id))
 
+        if self.workspace_id is None:
+            self.workspace_id = self.project_info.workspace_id
+            environ["WORKSPACE_ID"] = str(self.workspace_id)
+        if self.team_id is None:
+            self.team_id = self.project_info.team_id
+            environ["TEAM_ID"] = str(self.team_id)
+
         # 1. Project selection + Train/val split
         self.input_selector = InputSelector(self.project_info, self.app_options)
         # 2. Select train val splits
@@ -90,7 +98,7 @@ class TrainGUI:
         self.training_logs = TrainingLogs(self.app_options)
 
         # 8. Training Artifacts
-        self.training_artifacts = TrainingArtifacts(self.app_options)
+        self.training_artifacts = TrainingArtifacts(self._api, self.app_options)
 
         # Stepper layout
         self.steps = [

supervisely/nn/training/gui/training_artifacts.py

@@ -1,6 +1,10 @@
+import os
 from typing import Any, Dict
 
+import supervisely.io.env as sly_env
 from supervisely import Api
+from supervisely._utils import is_production
+from supervisely.api.api import ApiField
 from supervisely.app.widgets import (
     Card,
     Container,
@@ -11,18 +15,24 @@ from supervisely.app.widgets import (
     ReportThumbnail,
     Text,
 )
+from supervisely.io.fs import file_exists
 
 PYTORCH_ICON = "https://img.icons8.com/?size=100&id=jH4BpkMnRrU5&format=png&color=000000"
 ONNX_ICON = "https://artwork.lfaidata.foundation/projects/onnx/icon/color/onnx-icon-color.png"
 TRT_ICON = "https://img.icons8.com/?size=100&id=yqf95864UzeQ&format=png&color=000000"
 
+OVERVIEW_FILE_NAME = "README.md"
+PYTORCH_FILE_NAME = "demo_pytorch.py"
+ONNX_FILE_NAME = "demo_onnx.py"
+TRT_FILE_NAME = "demo_tensorrt.py"
+
 
 class TrainingArtifacts:
     title = "Training Artifacts"
     description = "All outputs of the training process will appear here"
     lock_message = "Artifacts will be available after training is completed"
 
-    def __init__(self, app_options: Dict[str, Any]):
+    def __init__(self, api: Api, app_options: Dict[str, Any]):
         self.display_widgets = []
         self.success_message_text = (
             "Training completed. Training artifacts were uploaded to Team Files. "
@@ -73,59 +83,107 @@ class TrainingArtifacts:
         # -------------------------------- #
 
         # PyTorch, ONNX, TensorRT demo
-        self.inference_demo_field = []
+        self.inference_demo_widgets = []
+
         model_demo = self.app_options.get("demo", None)
         if model_demo is not None:
-            pytorch_demo_link = model_demo.get("pytorch", None)
-            if pytorch_demo_link is not None:
-                pytorch_icon = Field.Icon(image_url=PYTORCH_ICON, bg_color_rgb=[255, 255, 255])
-                self.pytorch_instruction = Field(
-                    title="PyTorch",
-                    description="Open file",
-                    description_url=pytorch_demo_link,
-                    icon=pytorch_icon,
-                    content=Empty(),
-                )
-                self.pytorch_instruction.hide()
-                self.inference_demo_field.extend([self.pytorch_instruction])
-
-            onnx_demo_link = model_demo.get("onnx", None)
-            if onnx_demo_link is not None:
-                if self.app_options.get("export_onnx_supported", False):
-                    onnx_icon = Field.Icon(image_url=ONNX_ICON, bg_color_rgb=[255, 255, 255])
-                    self.onnx_instruction = Field(
-                        title="ONNX",
-                        description="Open file",
-                        description_url=onnx_demo_link,
-                        icon=onnx_icon,
-                        content=Empty(),
+            model_demo_path = model_demo.get("path", None)
+            if model_demo_path is not None:
+                model_demo_gh_link = None
+                if is_production():
+                    task_id = sly_env.task_id()
+                    task_info = api.task.get_info_by_id(task_id)
+                    app_id = task_info["meta"]["app"]["id"]
+                    app_info = api.app.get_info_by_id(app_id)
+                    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=True,
                     )
-                    self.onnx_instruction.hide()
-                    self.inference_demo_field.extend([self.onnx_instruction])
-
-            trt_demo_link = model_demo.get("tensorrt", None)
-            if trt_demo_link is not None:
-                if self.app_options.get("export_tensorrt_supported", False):
-                    trt_icon = Field.Icon(image_url=TRT_ICON, bg_color_rgb=[255, 255, 255])
-                    self.trt_instruction = Field(
-                        title="TensorRT",
-                        description="Open file",
-                        description_url=trt_demo_link,
-                        icon=trt_icon,
-                        content=Empty(),
-                    )
-                    self.trt_instruction.hide()
-                    self.inference_demo_field.extend([self.trt_instruction])
-
-            demo_overview_link = model_demo.get("overview", None)
-            self.inference_demo_field = Field(
-                title="How to run inference",
-                description="Instructions on how to use your checkpoints outside of Supervisely Platform",
-                content=Flexbox(self.inference_demo_field),
-                title_url=demo_overview_link,
-            )
-            self.inference_demo_field.hide()
-            self.display_widgets.extend([self.inference_demo_field])
+                    if len(apps) == 1:
+                        app_info = apps[0]
+                        model_demo_gh_link = app_info.repo
+
+                if model_demo_gh_link is not None:
+                    gh_branch = "blob/main"
+                    link_to_demo = f"{model_demo_gh_link}/{gh_branch}/{model_demo_path}"
+
+                    if model_demo_gh_link is not None and model_demo_path is not None:
+                        # PyTorch
+                        local_pytorch_demo = os.path.join(
+                            os.getcwd(), model_demo_path, PYTORCH_FILE_NAME
+                        )
+                        if file_exists(local_pytorch_demo):
+                            pytorch_demo_link = f"{link_to_demo}/{PYTORCH_FILE_NAME}"
+                            pytorch_icon = Field.Icon(
+                                image_url=PYTORCH_ICON, bg_color_rgb=[255, 255, 255]
+                            )
+                            self.pytorch_instruction = Field(
+                                title="PyTorch",
+                                description="Open file",
+                                description_url=pytorch_demo_link,
+                                icon=pytorch_icon,
+                                content=Empty(),
+                            )
+                            self.pytorch_instruction.hide()
+                            self.inference_demo_widgets.extend([self.pytorch_instruction])
+
+                        # ONNX
+                        local_onnx_demo = os.path.join(os.getcwd(), model_demo_path, ONNX_FILE_NAME)
+                        if file_exists(local_onnx_demo):
+                            if self.app_options.get("export_onnx_supported", False):
+                                onnx_demo_link = f"{link_to_demo}/{ONNX_FILE_NAME}"
+                                onnx_icon = Field.Icon(
+                                    image_url=ONNX_ICON, bg_color_rgb=[255, 255, 255]
+                                )
+                                self.onnx_instruction = Field(
+                                    title="ONNX",
+                                    description="Open file",
+                                    description_url=onnx_demo_link,
+                                    icon=onnx_icon,
+                                    content=Empty(),
+                                )
+                                self.onnx_instruction.hide()
+                                self.inference_demo_widgets.extend([self.onnx_instruction])
+
+                        # TensorRT
+                        local_trt_demo = os.path.join(os.getcwd(), model_demo_path, TRT_FILE_NAME)
+                        if file_exists(local_trt_demo):
+                            if self.app_options.get("export_tensorrt_supported", False):
+                                trt_demo_link = f"{link_to_demo}/{TRT_FILE_NAME}"
+                                trt_icon = Field.Icon(
+                                    image_url=TRT_ICON, bg_color_rgb=[255, 255, 255]
+                                )
+                                self.trt_instruction = Field(
+                                    title="TensorRT",
+                                    description="Open file",
+                                    description_url=trt_demo_link,
+                                    icon=trt_icon,
+                                    content=Empty(),
+                                )
+                                self.trt_instruction.hide()
+                                self.inference_demo_widgets.extend([self.trt_instruction])
+
+                        local_demo_overview = os.path.join(
+                            os.getcwd(), model_demo_path, OVERVIEW_FILE_NAME
+                        )
+                        if file_exists(local_demo_overview):
+                            demo_overview_link = os.path.join(link_to_demo, OVERVIEW_FILE_NAME)
+                        else:
+                            demo_overview_link = None
+
+                        self.inference_demo_field = Field(
+                            title="How to run inference",
+                            description="Instructions on how to use your checkpoints outside of Supervisely Platform",
+                            content=Flexbox(self.inference_demo_widgets),
+                            title_url=demo_overview_link,
+                        )
+                        self.inference_demo_field.hide()
+                        self.display_widgets.extend([self.inference_demo_field])
         # -------------------------------- #
 
         self.container = Container(self.display_widgets)
@@ -143,3 +201,15 @@ class TrainingArtifacts:
 
     def validate_step(self) -> bool:
         return True
+
+    def overview_demo_exists(self, demo_path: str):
+        return file_exists(os.path.join(os.getcwd(), demo_path, OVERVIEW_FILE_NAME))
+
+    def pytorch_demo_exists(self, demo_path: str):
+        return file_exists(os.path.join(os.getcwd(), demo_path, PYTORCH_FILE_NAME))
+
+    def onnx_demo_exists(self, demo_path: str):
+        return file_exists(os.path.join(os.getcwd(), demo_path, ONNX_FILE_NAME))
+
+    def trt_demo_exists(self, demo_path: str):
+        return file_exists(os.path.join(os.getcwd(), demo_path, TRT_FILE_NAME))

supervisely/nn/training/train_app.py

@@ -8,7 +8,7 @@ training workflows in a Supervisely application.
 import shutil
 import subprocess
 from datetime import datetime
-from os import listdir
+from os import getcwd, listdir
 from os.path import basename, exists, expanduser, isdir, isfile, join
 from typing import Any, Dict, List, Literal, Optional, Union
 from urllib.request import urlopen
@@ -124,8 +124,6 @@ class TrainApp:
             logger.info("TrainApp is running in debug mode")
 
         self.framework_name = framework_name
-        self._team_id = sly_env.team_id()
-        self._workspace_id = sly_env.workspace_id()
         self._tensorboard_process = None
 
         self._models = self._load_models(models)
@@ -249,6 +247,26 @@ class TrainApp:
     # ----------------------------------------- #
 
     # Input Data
+    @property
+    def team_id(self) -> int:
+        """
+        Returns the ID of the team.
+
+        :return: Team ID.
+        :rtype: int
+        """
+        return self.gui.team_id
+
+    @property
+    def workspace_id(self) -> int:
+        """
+        Returns the ID of the workspace.
+
+        :return: Workspace ID.
+        :rtype: int
+        """
+        return self.gui.workspace_id
+
     @property
     def project_id(self) -> int:
         """
@@ -555,6 +573,7 @@ class TrainApp:
         self._generate_hyperparameters(remote_dir, experiment_info)
         self._generate_train_val_splits(remote_dir, splits_data)
         self._generate_model_meta(remote_dir, experiment_info)
+        self._upload_demo_files(remote_dir)
 
         # Step 7. Set output widgets
         self._set_text_status("reset")
@@ -1074,7 +1093,7 @@ class TrainApp:
         ) as model_download_main_pbar:
             self.progress_bar_main.show()
             for name, remote_path in remote_paths.items():
-                file_info = self._api.file.get_info_by_path(self._team_id, remote_path)
+                file_info = self._api.file.get_info_by_path(self.team_id, remote_path)
                 file_name = basename(remote_path)
                 local_path = join(self.model_dir, file_name)
                 file_size = file_info.sizeb
@@ -1087,7 +1106,7 @@ class TrainApp:
                 ) as model_download_secondary_pbar:
                     self.progress_bar_secondary.show()
                     self._api.file.download(
-                        self._team_id,
+                        self.team_id,
                         remote_path,
                         local_path,
                         progress_cb=model_download_secondary_pbar.update,
@@ -1325,7 +1344,7 @@ class TrainApp:
         ) as upload_artifacts_pbar:
             self.progress_bar_main.show()
             self._api.file.upload(
-                self._team_id,
+                self.team_id,
                 local_path,
                 remote_path,
                 progress_cb=upload_artifacts_pbar,
@@ -1421,7 +1440,7 @@ class TrainApp:
 
         remote_checkpoints_dir = join(remote_dir, self._remote_checkpoints_dir_name)
         checkpoint_files = self._api.file.list(
-            self._team_id, remote_checkpoints_dir, return_type="fileinfo"
+            self.team_id, remote_checkpoints_dir, return_type="fileinfo"
         )
         experiment_info["checkpoints"] = [
             f"checkpoints/{checkpoint.name}" for checkpoint in checkpoint_files
@@ -1482,6 +1501,38 @@ class TrainApp:
             local_path, remote_path, f"Uploading '{self._app_state_file}' to Team Files"
         )
 
+    def _upload_demo_files(self, remote_dir: str) -> None:
+        demo = self._app_options.get("demo")
+        if demo is None:
+            return
+        demo_path = demo.get("path")
+        if demo_path is None:
+            return
+
+        local_demo_dir = join(getcwd(), demo_path)
+        if not sly_fs.dir_exists(local_demo_dir):
+            logger.info(f"Demo directory '{local_demo_dir}' does not exist")
+            return
+
+        logger.debug(f"Uploading demo files to Supervisely")
+        remote_demo_dir = join(remote_dir, "demo")
+        local_files = sly_fs.list_files_recursively(local_demo_dir)
+        total_size = sum([sly_fs.get_file_size(file_path) for file_path in local_files])
+        with self.progress_bar_main(
+            message="Uploading demo files to Team Files",
+            total=total_size,
+            unit="bytes",
+            unit_scale=True,
+        ) as upload_artifacts_pbar:
+            self.progress_bar_main.show()
+            remote_dir = self._api.file.upload_directory(
+                self.team_id,
+                local_demo_dir,
+                remote_demo_dir,
+                progress_size_cb=upload_artifacts_pbar,
+            )
+            self.progress_bar_main.hide()
+
     def _get_train_val_splits_for_app_state(self) -> Dict:
         """
         Gets the train and val splits information for app_state.json.
@@ -1557,13 +1608,13 @@ class TrainApp:
 
         # Clean debug directory if exists
         if task_id == "debug-session":
-            if self._api.file.dir_exists(self._team_id, f"{remote_artifacts_dir}/", True):
+            if self._api.file.dir_exists(self.team_id, f"{remote_artifacts_dir}/", True):
                 with self.progress_bar_main(
                     message=f"[Debug] Cleaning train artifacts: '{remote_artifacts_dir}/'",
                     total=1,
                 ) as upload_artifacts_pbar:
                     self.progress_bar_main.show()
-                    self._api.file.remove_dir(self._team_id, f"{remote_artifacts_dir}", True)
+                    self._api.file.remove_dir(self.team_id, f"{remote_artifacts_dir}", True)
                     upload_artifacts_pbar.update(1)
                     self.progress_bar_main.hide()
 
@@ -1586,14 +1637,14 @@ class TrainApp:
         ) as upload_artifacts_pbar:
             self.progress_bar_main.show()
             remote_dir = self._api.file.upload_directory(
-                self._team_id,
+                self.team_id,
                 self.output_dir,
                 remote_artifacts_dir,
                 progress_size_cb=upload_artifacts_pbar,
             )
             self.progress_bar_main.hide()
 
-        file_info = self._api.file.get_info_by_path(self._team_id, join(remote_dir, "open_app.lnk"))
+        file_info = self._api.file.get_info_by_path(self.team_id, join(remote_dir, "open_app.lnk"))
         return remote_dir, file_info
 
     def _set_training_output(
@@ -1629,33 +1680,36 @@ class TrainApp:
 
         # Set instruction to GUI
         demo_options = self._app_options.get("demo", {})
-        if demo_options:
+        demo_path = demo_options.get("path", None)
+        if demo_path is not None:
             # Show PyTorch demo if available
-            pytorch_demo = demo_options.get("pytorch")
-            if pytorch_demo:
+            if self.gui.training_artifacts.pytorch_demo_exists(demo_path):
                 self.gui.training_artifacts.pytorch_instruction.show()
 
             # Show ONNX demo if supported and available
-            onnx_demo = demo_options.get("onnx")
             if (
                 self._app_options.get("export_onnx_supported", False)
                 and self.gui.hyperparameters_selector.get_export_onnx_checkbox_value()
-                and onnx_demo
+                and self.gui.training_artifacts.onnx_demo_exists(demo_path)
             ):
                 self.gui.training_artifacts.onnx_instruction.show()
 
             # Show TensorRT demo if supported and available
-            tensorrt_demo = demo_options.get("tensorrt")
             if (
                 self._app_options.get("export_tensorrt_supported", False)
                 and self.gui.hyperparameters_selector.get_export_tensorrt_checkbox_value()
-                and tensorrt_demo
+                and self.gui.training_artifacts.trt_demo_exists(demo_path)
             ):
                 self.gui.training_artifacts.trt_instruction.show()
 
             # Show the inference demo widget if overview or any demo is available
-            demo_overview = self._app_options.get("overview", {})
-            if demo_overview or any([pytorch_demo, onnx_demo, tensorrt_demo]):
+            if self.gui.training_artifacts.overview_demo_exists(demo_path) or any(
+                [
+                    self.gui.training_artifacts.pytorch_demo_exists(demo_path),
+                    self.gui.training_artifacts.onnx_demo_exists(demo_path),
+                    self.gui.training_artifacts.trt_demo_exists(demo_path),
+                ]
+            ):
                 self.gui.training_artifacts.inference_demo_field.show()
         # ---------------------------- #
 
@@ -1676,7 +1730,7 @@ class TrainApp:
         eval_res_dir = (
             f"/model-benchmark/{self.project_info.id}_{self.project_info.name}/{task_dir}/"
         )
-        eval_res_dir = self._api.storage.get_free_dir_name(self._team_id, eval_res_dir)
+        eval_res_dir = self._api.storage.get_free_dir_name(self.team_id, eval_res_dir)
         return eval_res_dir
 
     def _run_model_benchmark(
@@ -1742,6 +1796,8 @@ class TrainApp:
                 use_gui=False,
                 custom_inference_settings=self._inference_settings,
             )
+            if hasattr(m, "in_train"):
+                m.in_train = True
 
             logger.info(f"Using device: {self.device}")
 
@@ -1910,7 +1966,7 @@ class TrainApp:
 
             if self.model_source == ModelSource.CUSTOM:
                 file_info = self._api.file.get_info_by_path(
-                    self._team_id,
+                    self.team_id,
                     self.gui.model_selector.experiment_selector.get_selected_checkpoint_path(),
                 )
                 if file_info is not None:
@@ -2319,7 +2375,7 @@ class TrainApp:
                     self.progress_bar_secondary.show()
                     destination_path = join(remote_dir, self._export_dir_name, file_name)
                     self._api.file.upload(
-                        self._team_id,
+                        self.team_id,
                         path,
                         destination_path,
                         export_upload_secondary_pbar,

{supervisely-6.73.269.dist-info → supervisely-6.73.271.dist-info}/METADATA

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

{supervisely-6.73.269.dist-info → supervisely-6.73.271.dist-info}/RECORD

@@ -25,7 +25,7 @@ supervisely/api/annotation_api.py,sha256=kB9l0NhQEkunGDC9fWjNzf5DdhqRF1tv-RRnIbk
 supervisely/api/api.py,sha256=0dgPx_eizoCEFzfT8YH9uh1kq-OJwjrV5fBGD7uZ7E4,65840
 supervisely/api/app_api.py,sha256=RsbVej8WxWVn9cNo5s3Fqd1symsCdsfOaKVBKEUapRY,71927
 supervisely/api/dataset_api.py,sha256=GH7prDRJKyJlTv_7_Y-RkTwJN7ED4EkXNqqmi3iIdI4,41352
-supervisely/api/file_api.py,sha256=7yWt8lRQ4UfLmnMZ9T18UXzu8jihrtHtcqi6GZJG-0w,83414
+supervisely/api/file_api.py,sha256=v2FsD3oljwNPqcDgEJRe8Bu5k0PYKzVhqmRb5QFaHAQ,83422
 supervisely/api/github_api.py,sha256=NIexNjEer9H5rf5sw2LEZd7C1WR-tK4t6IZzsgeAAwQ,623
 supervisely/api/image_annotation_tool_api.py,sha256=YcUo78jRDBJYvIjrd-Y6FJAasLta54nnxhyaGyanovA,5237
 supervisely/api/image_api.py,sha256=lLt8z_OE7cXwb94_UKxWiSKxe28a4meMrVM7dhHIWZY,176956
@@ -864,7 +864,7 @@ supervisely/nn/benchmark/visualization/widgets/table/__init__.py,sha256=47DEQpj8
 supervisely/nn/benchmark/visualization/widgets/table/table.py,sha256=atmDnF1Af6qLQBUjLhK18RMDKAYlxnsuVHMSEa5a-e8,4319
 supervisely/nn/inference/__init__.py,sha256=mtEci4Puu-fRXDnGn8RP47o97rv3VTE0hjbYO34Zwqg,1622
 supervisely/nn/inference/cache.py,sha256=_pPSpkl8Wkqkiidn0vu6kWE19cngd80av--jncHxMEQ,30510
-supervisely/nn/inference/inference.py,sha256=8MrOen2oyYIKiVqy0WbBTwABJZss9MLQ70EwX0e_-es,128895
+supervisely/nn/inference/inference.py,sha256=IDkMFsURnB-vBM-2Kf-M7D5IQw6VUoIwVoh_IIdzA9Q,143958
 supervisely/nn/inference/session.py,sha256=jmkkxbe2kH-lEgUU6Afh62jP68dxfhF5v6OGDfLU62E,35757
 supervisely/nn/inference/video_inference.py,sha256=8Bshjr6rDyLay5Za8IB8Dr6FURMO2R_v7aELasO8pR4,5746
 supervisely/nn/inference/gui/__init__.py,sha256=wCxd-lF5Zhcwsis-wScDA8n1Gk_1O00PKgDviUZ3F1U,221
@@ -960,15 +960,15 @@ supervisely/nn/tracker/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 supervisely/nn/tracker/utils/gmc.py,sha256=3JX8979H3NA-YHNaRQyj9Z-xb9qtyMittPEjGw8y2Jo,11557
 supervisely/nn/tracker/utils/kalman_filter.py,sha256=eSFmCjM0mikHCAFvj-KCVzw-0Jxpoc3Cfc2NWEjJC1Q,17268
 supervisely/nn/training/__init__.py,sha256=gY4PCykJ-42MWKsqb9kl-skemKa8yB6t_fb5kzqR66U,111
-supervisely/nn/training/train_app.py,sha256=Q3evZS3DChaWMEB7kZrabMSsHv621-XEQuyGdfq91nY,93101
+supervisely/nn/training/train_app.py,sha256=wXWQb6Xa49nNHNjCe1YuSur-vHqwjk_J0yoQYCKjHWw,94989
 supervisely/nn/training/gui/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 supervisely/nn/training/gui/classes_selector.py,sha256=8UgzA4aogOAr1s42smwEcDbgaBj_i0JLhjwlZ9bFdIA,3772
-supervisely/nn/training/gui/gui.py,sha256=ERMyRqZABLBXcLxvvsF1TtL8VKK8Ak4MwoN9wrL4Dzw,23357
+supervisely/nn/training/gui/gui.py,sha256=nj4EVppoV9ZjLN0rVO0GKxmI56d6Qpp0qwnJJ6srT6w,23712
 supervisely/nn/training/gui/hyperparameters_selector.py,sha256=2qryuBss0bLcZJV8PNJ6_hKZM5Dbj2FIxTb3EULHQrE,6670
 supervisely/nn/training/gui/input_selector.py,sha256=Jp9PnVVADv1fhndPuZdMlKuzWTOBQZogrOks5dwATlc,2179
 supervisely/nn/training/gui/model_selector.py,sha256=QTFHMf-8-rREYPk64QKoRvE4zKPC8V6tcP4H4N6nyt0,4082
 supervisely/nn/training/gui/train_val_splits_selector.py,sha256=MLryFD2Tj_RobkFzZOeQXzXpch0eGiVFisq3FGA3dFg,8549
-supervisely/nn/training/gui/training_artifacts.py,sha256=JoeNn1cXSRrkatjxhYNwL_-yDsBT2aqYugjICMn4KUk,5887
+supervisely/nn/training/gui/training_artifacts.py,sha256=-sJQu5kBaJJp8JhSZzHpQdV4lJFjbd2YOaovbQPyVLM,9583
 supervisely/nn/training/gui/training_logs.py,sha256=1CBqnL0l5kiZVaegJ-NLgOVI1T4EDB_rLAtumuw18Jo,3222
 supervisely/nn/training/gui/training_process.py,sha256=wqlwt1cHG-HoVEOotDiBjp9YTTIbeMr1bHY2zVRaNH8,3071
 supervisely/nn/training/gui/utils.py,sha256=Bi7-BRsAqN7fUkhd7rXVEAqsxhBdIZ2MrrJtrNqVf8I,3905
@@ -1062,9 +1062,9 @@ supervisely/worker_proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 supervisely/worker_proto/worker_api_pb2.py,sha256=VQfi5JRBHs2pFCK1snec3JECgGnua3Xjqw_-b3aFxuM,59142
 supervisely/worker_proto/worker_api_pb2_grpc.py,sha256=3BwQXOaP9qpdi0Dt9EKG--Lm8KGN0C5AgmUfRv77_Jk,28940
 supervisely_lib/__init__.py,sha256=7-3QnN8Zf0wj8NCr2oJmqoQWMKKPKTECvjH9pd2S5vY,159
-supervisely-6.73.269.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.269.dist-info/METADATA,sha256=NZRYDDissMNHAzHNf8M4N6lVnQCMVCMf5DsJTLKcFb8,33573
-supervisely-6.73.269.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-supervisely-6.73.269.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.269.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.269.dist-info/RECORD,,
+supervisely-6.73.271.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.271.dist-info/METADATA,sha256=sRSopR2p5d0tsyK9jC8MYDBbhngm6uX8Z2eQY76yQjE,33573
+supervisely-6.73.271.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+supervisely-6.73.271.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.271.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.271.dist-info/RECORD,,