supervisely 6.73.438__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/nn/training/train_app.py

@@ -43,6 +43,7 @@ from supervisely import (
     logger,
 )
 from supervisely._utils import abs_url, get_filename_from_headers
+from supervisely.api.entities_collection_api import EntitiesCollectionInfo
 from supervisely.api.file_api import FileInfo
 from supervisely.app import get_synced_data_dir, show_dialog
 from supervisely.app.widgets import Progress
@@ -72,7 +73,6 @@ from supervisely.project.download import (
     is_cached,
 )
 from supervisely.template.experiment.experiment_generator import ExperimentGenerator
-from supervisely.api.entities_collection_api import EntitiesCollectionInfo
 
 
 class TrainApp:
@@ -1598,13 +1598,18 @@ class TrainApp:
                 project_id = self.project_id
 
             dataset_infos = [dataset for _, dataset in self._api.dataset.tree(project_id)]
+            id_to_info = {ds.id: ds for ds in dataset_infos}
             ds_infos_dict = {}
             for dataset in dataset_infos:
-                if dataset.parent_id is not None:
-                    parent_ds = self._api.dataset.get_info_by_id(dataset.parent_id)
-                    dataset_name = f"{parent_ds.name}/{dataset.name}"
-                else:
-                    dataset_name = dataset.name
+                name_parts = [dataset.name]
+                parent_id = dataset.parent_id
+                while parent_id is not None:
+                    parent_ds = id_to_info.get(parent_id)
+                    if parent_ds is None:
+                        parent_ds = self._api.dataset.get_info_by_id(parent_id)
+                    name_parts.append(parent_ds.name)
+                    parent_id = parent_ds.parent_id
+                dataset_name = "/".join(reversed(name_parts))
                 ds_infos_dict[dataset_name] = dataset
 
             def get_image_infos_by_split(ds_infos_dict: dict, split: list):
@@ -3157,8 +3162,11 @@ class TrainApp:
 
         # Case 1: Use existing collections for training. No need to create new collections
         split_method = self.gui.train_val_splits_selector.get_split_method()
+        self.gui.train_val_splits_selector._parse_collections()
         all_train_collections = self.gui.train_val_splits_selector.all_train_collections
         all_val_collections = self.gui.train_val_splits_selector.all_val_collections
+        latest_train_collection = self.gui.train_val_splits_selector.latest_train_collection
+        latest_val_collection = self.gui.train_val_splits_selector.latest_val_collection
         if split_method == "Based on collections":
             current_selected_train_collection_ids = self.gui.train_val_splits_selector.train_val_splits.get_train_collections_ids()
             train_match = _check_match(current_selected_train_collection_ids, all_train_collections)
@@ -3173,44 +3181,51 @@ class TrainApp:
         # ------------------------------------------------------------ #
 
         # Case 2: Create new collections for selected train val splits. Need to create new collections
-        item_type = self.project_info.type
-        experiment_name = self.gui.training_process.get_experiment_name()
-
         train_collection_idx = 1
-        val_collection_idx = 1        
+        val_collection_idx = 1
+
+        def _extract_index_from_col_name(name: str, expected_prefix: str) -> Optional[int]:
+            parts = name.split("_")
+            if len(parts) == 2 and parts[0] == expected_prefix and parts[1].isdigit():
+                return int(parts[1])
+            return None
 
         # Get train collection with max idx
-        if len(all_train_collections) > 0:
-            train_collection_idx = max([int(collection.name.split("_")[1]) for collection in all_train_collections])
-            train_collection_idx += 1
+        if latest_train_collection:
+            train_collection_idx = (
+                _extract_index_from_col_name(latest_train_collection.name, "train") + 1
+            )
+
         # Get val collection with max idx
-        if len(all_val_collections) > 0:
-            val_collection_idx = max([int(collection.name.split("_")[1]) for collection in all_val_collections])
-            val_collection_idx += 1
+        if latest_val_collection:
+            val_collection_idx = _extract_index_from_col_name(latest_val_collection.name, "val") + 1
         # -------------------------------- #
 
         # Create Train Collection
         train_img_ids = list(self._train_split_item_ids)
-        train_collection_description = f"Collection with train {item_type} for experiment: {experiment_name}"
-        train_collection = self._api.entities_collection.create(self.project_id, f"train_{train_collection_idx}", train_collection_description)
-        train_collection_id = getattr(train_collection, "id", None)
-        if train_collection_id is None:
-            raise AttributeError("Train EntitiesCollectionInfo object does not have 'id' attribute")
-        self._api.entities_collection.add_items(train_collection_id, train_img_ids)
-        self._train_collection_id = train_collection_id
+        self._train_collection_id = self._create_collection("train", train_collection_idx)
+        self._api.entities_collection.add_items(self._train_collection_id, train_img_ids)
 
         # Create Val Collection
         val_img_ids = list(self._val_split_item_ids)
-        val_collection_description = f"Collection with val {item_type} for experiment: {experiment_name}"
-        val_collection = self._api.entities_collection.create(self.project_id, f"val_{val_collection_idx}", val_collection_description)
-        val_collection_id = getattr(val_collection, "id", None)
-        if val_collection_id is None:
-            raise AttributeError("Val EntitiesCollectionInfo object does not have 'id' attribute")
-        self._api.entities_collection.add_items(val_collection_id, val_img_ids)
-        self._val_collection_id = val_collection_id
+        self._val_collection_id = self._create_collection("val", val_collection_idx)
+        self._api.entities_collection.add_items(self._val_collection_id, val_img_ids)
 
         # Update Project Custom Data
-        self._update_project_custom_data(train_collection_id, val_collection_id)
+        self._update_project_custom_data(self._train_collection_id, self._val_collection_id)
+
+    def _create_collection(self, split_type: str, suffix: int) -> int:
+        experiment_name = self.gui.training_process.get_experiment_name()
+        description = f"Collection with {split_type} {self.project_info.type} for experiment: {experiment_name}"
+        collection = self._api.entities_collection.create(
+            project_id=self.project_id,
+            name=f"{split_type}_{suffix:03d}",
+            description=description,
+            change_name_if_conflict=True,
+        )
+        if collection is None or collection.id is None:  # pylint: disable=no-member
+            raise RuntimeError(f"Failed to create {split_type} collection")
+        return collection.id  # pylint: disable=no-member
 
     def _update_project_custom_data(self, train_collection_id: int, val_collection_id: int):
         train_info = {

supervisely/project/data_version.py

@@ -14,7 +14,12 @@ from supervisely.api.module_api import ApiField, ModuleApiBase
 from supervisely.api.project_api import ProjectInfo
 from supervisely.io import json
 from supervisely.io.fs import remove_dir, silent_remove
-
+from supervisely.project.versioning.schema_fields import VersionSchemaField
+from supervisely.project.versioning.common import (
+    DEFAULT_IMAGE_SCHEMA_VERSION,
+    DEFAULT_VIDEO_SCHEMA_VERSION,
+    DEFAULT_VOLUME_SCHEMA_VERSION,
+)
 
 class VersionInfo(NamedTuple):
     """
@@ -49,7 +54,7 @@ class DataVersion(ModuleApiBase):
 
         self._api: Api = api
         self.__storage_dir: str = "/system/versions/"
-        self.__version_format: str = "v1.0.0"
+        self.__version_format: str = DEFAULT_IMAGE_SCHEMA_VERSION
         self.project_info = None
         self.project_dir = None
         self.versions_path = None
@@ -84,6 +89,31 @@ class DataVersion(ModuleApiBase):
         """
         return "VersionInfo"
 
+    @property
+    def project_cls(self):
+        from supervisely.project import (
+            Project,
+            ProjectType,
+            VideoProject,
+            VolumeProject,
+        )
+
+        if self.project_info is None:
+            raise ValueError("Project info is not initialized. Call 'initialize' method first.")
+
+        project_type = self.project_info.type
+        if project_type == ProjectType.IMAGES.value:
+            self.__version_format = DEFAULT_IMAGE_SCHEMA_VERSION
+            return Project
+        elif project_type == ProjectType.VIDEOS.value:
+            self.__version_format = DEFAULT_VIDEO_SCHEMA_VERSION
+            return VideoProject
+        elif project_type == ProjectType.VOLUMES.value:
+            self.__version_format = DEFAULT_VOLUME_SCHEMA_VERSION
+            return VolumeProject
+        else:
+            raise ValueError(f"Unsupported project type: {project_type}")
+
     def initialize(self, project_info: Union[ProjectInfo, int]):
         """
         Initialize project versions.
@@ -158,10 +188,10 @@ class DataVersion(ModuleApiBase):
             versions = self._api.file.get_json_file_content(
                 self.project_info.team_id, self.versions_path
             )
-            versions = versions if versions else {}
+            return versions or {}
         except FileNotFoundError:
-            versions = {"format": self.__version_format}
-        return versions
+            # versions = {"format": self.__version_format}
+            return {}
 
     def set_map(self, project_info: Union[ProjectInfo, int], initialize: bool = True):
         """
@@ -176,6 +206,8 @@ class DataVersion(ModuleApiBase):
 
         if initialize:
             self.initialize(project_info)
+        if "format" not in self.versions:
+            self.versions["format"] = self.__version_format
         temp_dir = tempfile.mkdtemp()
         local_versions = os.path.join(temp_dir, "versions.json")
         json.dump_json_file(self.versions, local_versions)
@@ -329,21 +361,32 @@ class DataVersion(ModuleApiBase):
                 return reserve_info.get(ApiField.ID), reserve_info.get(ApiField.COMMIT_TOKEN)
 
             except requests.exceptions.HTTPError as e:
-                if e.response.json().get("details", {}).get("useExistingVersion"):
-                    version_id = e.response.json().get("details", {}).get("version").get("id")
-                    version = e.response.json().get("details", {}).get("version").get("version")
+                details = {}
+                if e.response is not None:
+                    try:
+                        details = (e.response.json() or {}).get("details", {})  # type: ignore[union-attr]
+                    except Exception:
+                        details = {}
+
+                if details.get("useExistingVersion"):
+                    version_id = details.get("version", {}).get("id")
+                    version = details.get("version", {}).get("version")
                     logger.info(
                         f"No changes to the project since the last version '{version}' with ID '{version_id}'"
                     )
                     return (None, None)
-                elif "is already committing" in e.response.json().get("details", {}).get("message"):
+
+                message = (details.get("message") or "").lower()
+                if "is already committing" in message:
                     if retry_delay >= max_delay:
                         raise RuntimeError(
                             "Failed to reserve version. Another process is already committing a version. Maximum number of attempts reached."
                         )
-                    version = e.response.json().get("details", {}).get("version").get("version")
                     time.sleep(retry_delay)
                     retry_delay *= 2
+                    continue
+
+                raise
 
     def cancel_reservation(self, version_id: int, commit_token: str):
         """
@@ -384,8 +427,6 @@ class DataVersion(ModuleApiBase):
         :return: ProjectInfo object of the restored project
         :rtype: ProjectInfo or None
         """
-        from supervisely.project.project import Project
-
         if version_id is None and version_num is None:
             raise ValueError("Either version_id or version_num must be provided")
 
@@ -421,7 +462,7 @@ class DataVersion(ModuleApiBase):
             return
 
         bin_io = self._download_and_extract(backup_files)
-        new_project_info = Project.upload_bin(
+        new_project_info = self.project_cls.upload_bin(
             self._api,
             bin_io,
             self.project_info.workspace_id,
@@ -456,15 +497,28 @@ class DataVersion(ModuleApiBase):
         local_path = os.path.join(temp_dir, "download.tar.zst")
         try:
             self._api.file.download(self.project_info.team_id, path, local_path)
-            with open(local_path, "rb") as zst:
-                decompressed_data = zstd.decompress(zst.read())
-            with tarfile.open(fileobj=io.BytesIO(decompressed_data)) as tar:
-                file = tar.extractfile("version.bin")
-                if not file:
-                    raise RuntimeError("version.bin not found in the archive")
-                data = file.read()
-                bin_io = io.BytesIO(data)
-                return bin_io
+            # Stream-decompress and stream-read tar to avoid loading the whole archive in memory.
+            try:
+                dctx = zstd.ZstdDecompressor()
+                with open(local_path, "rb") as zst_f:
+                    with dctx.stream_reader(zst_f) as reader:
+                        with tarfile.open(fileobj=reader, mode="r|") as tar:
+                            for member in tar:
+                                if member.name == "version.bin":
+                                    file = tar.extractfile(member)
+                                    if not file:
+                                        raise RuntimeError("version.bin not found in the archive")
+                                    return io.BytesIO(file.read())
+                            raise RuntimeError("version.bin not found in the archive")
+            except Exception:
+                # Fallback: one-shot decompress
+                with open(local_path, "rb") as zst_f:
+                    decompressed_data = zstd.decompress(zst_f.read())
+                with tarfile.open(fileobj=io.BytesIO(decompressed_data), mode="r") as tar:
+                    file = tar.extractfile("version.bin")
+                    if not file:
+                        raise RuntimeError("version.bin not found in the archive")
+                    return io.BytesIO(file.read())
         except Exception as e:
             raise RuntimeError(f"Failed to extract version: {e}")
         finally:
@@ -501,34 +555,44 @@ class DataVersion(ModuleApiBase):
         :return: File info
         :rtype: dict
         """
-        from supervisely.project.project import Project
-
         temp_dir = tempfile.mkdtemp()
+        data = None
+        try:
+            data = self.project_cls.download_bin(
+                self._api, self.project_info.id, batch_size=200, return_bytesio=True
+            )
+            info = tarfile.TarInfo(name="version.bin")
+            data.seek(0, io.SEEK_END)
+            info.size = data.tell()
+            data.seek(0)
+            zst_archive_path = os.path.join(temp_dir, "download.tar.zst")
 
-        data = Project.download_bin(
-            self._api, self.project_info.id, batch_size=200, return_bytesio=True
-        )
-        data.seek(0)
-        info = tarfile.TarInfo(name="version.bin")
-        info.size = len(data.getvalue())
-        chunk_size = 1024 * 1024 * 50  # 50 MiB
-        tar_data = io.BytesIO()
-
-        # Create a tarfile object that writes into the BytesIO object
-        with tarfile.open(fileobj=tar_data, mode="w") as tar:
-            tar.addfile(tarinfo=info, fileobj=data)
-        data.close()
-        # Reset the BytesIO object's cursor to the beginning
-        tar_data.seek(0)
-        zst_archive_path = os.path.join(temp_dir, "download.tar.zst")
-
-        with open(zst_archive_path, "wb") as zst:
-            while True:
-                chunk = tar_data.read(chunk_size)
-                if not chunk:
-                    break
-                zst.write(zstd.compress(chunk))
-        file_info = self._api.file.upload(self.project_info.team_id, zst_archive_path, path)
-        tar_data.close()
-        remove_dir(temp_dir)
-        return file_info
+            # Stream-decompress and stream-read tar to avoid loading the whole archive in memory.
+            try:
+                cctx = zstd.ZstdCompressor()
+                with open(zst_archive_path, "wb") as zst_f:
+                    try:
+                        stream = cctx.stream_writer(zst_f, closefd=False)
+                    except TypeError:
+                        stream = cctx.stream_writer(zst_f)
+                    with stream as compressor:
+                        with tarfile.open(fileobj=compressor, mode="w|") as tar:
+                            tar.addfile(tarinfo=info, fileobj=data)
+            except Exception:
+                # Fallback: build tar in memory + one-shot compress
+                tar_data = io.BytesIO()
+                with tarfile.open(fileobj=tar_data, mode="w") as tar:
+                    tar.addfile(tarinfo=info, fileobj=data)
+                tar_data.seek(0)
+                with open(zst_archive_path, "wb") as zst_f:
+                    zst_f.write(zstd.compress(tar_data.read()))
+
+            file_info = self._api.file.upload(self.project_info.team_id, zst_archive_path, path)
+            return file_info
+        finally:
+            if data is not None:
+                try:
+                    data.close()
+                except Exception:
+                    pass
+            remove_dir(temp_dir)

supervisely/project/download.py

@@ -216,7 +216,7 @@ def download_async_or_sync(
     dataset_ids: Optional[List[int]] = None,
     log_progress: bool = True,
     progress_cb: Optional[Union[tqdm, Callable]] = None,
-    semaphore: Optional[asyncio.Semaphore] = None,
+    semaphore: Optional[Union[asyncio.Semaphore, int]] = None,
     **kwargs,
 ):
     """

supervisely/project/pointcloud_episode_project.py

@@ -655,6 +655,25 @@ class PointcloudEpisodeProject(PointcloudProject):
             f"Static method 'download_async()' is not supported for PointcloudEpisodeProject class now."
         )
 
+    # ----------------------------------- #
+    # Pointcloud Episodes Data Versioning #
+    # ----------------------------------- #
+    @staticmethod
+    def download_bin(*args, **kwargs):
+        raise NotImplementedError("Data versioning is not supported for PointcloudEpisodeProject.")
+
+    @staticmethod
+    def upload_bin(*args, **kwargs):
+        raise NotImplementedError("Data versioning is not supported for PointcloudEpisodeProject.")
+
+    @staticmethod
+    def build_snapshot(*args, **kwargs):
+        raise NotImplementedError("Data versioning is not supported for PointcloudEpisodeProject.")
+
+    @staticmethod
+    def restore_snapshot(*args, **kwargs):
+        raise NotImplementedError("Data versioning is not supported for PointcloudEpisodeProject.")
+
 
 def download_pointcloud_episode_project(
     api: Api,
@@ -946,7 +965,7 @@ def upload_pointcloud_episode_project(
     log_progress: bool = True,
     progress_cb: Optional[Union[tqdm, Callable]] = None,
 ) -> Tuple[int, str]:
-    # STEP 0 — create project remotely
+    # STEP 0 - create project remotely
     project_fs = PointcloudEpisodeProject.read_single(directory)
     project_name = project_fs.name if project_name is None else project_name
 
@@ -959,8 +978,9 @@ def upload_pointcloud_episode_project(
     if progress_cb is not None:
         log_progress = False
 
+    name_to_dsinfo = {}
     key_id_map = KeyIdMap()
-    for dataset_fs in project_fs.datasets:
+    for dataset_fs in sorted(project_fs.datasets, key=lambda ds: len(ds.parents)):
         dataset_fs: PointcloudEpisodeDataset
         ann_json_path = dataset_fs.get_ann_path()
 
@@ -970,14 +990,19 @@ def upload_pointcloud_episode_project(
         else:
             episode_annotation = PointcloudEpisodeAnnotation()
 
+        parent_path = dataset_fs.name.removesuffix(dataset_fs.short_name).rstrip("/")
+        parent_info = name_to_dsinfo.get(parent_path)
+        parent_id = parent_info.id if parent_info else None
         dataset = api.dataset.create(
             project.id,
-            dataset_fs.name,
+            dataset_fs.short_name,
             description=episode_annotation.description,
             change_name_if_conflict=True,
+            parent_id=parent_id,
         )
+        name_to_dsinfo[dataset_fs.name] = dataset
 
-        # STEP 1 — upload episodes
+        # STEP 1 - upload episodes
         items_infos = {"names": [], "paths": [], "metas": []}
 
         for item_name in dataset_fs:
@@ -989,6 +1014,10 @@ def upload_pointcloud_episode_project(
             items_infos["paths"].append(item_path)
             items_infos["metas"].append(item_meta)
 
+        if not items_infos["names"]:
+            logger.info(f"Dataset {dataset.name} has no items, skipping upload")
+            continue
+
         ds_progress = progress_cb
         if log_progress:
             ds_progress = tqdm_sly(
@@ -1015,7 +1044,7 @@ def upload_pointcloud_episode_project(
                 },
             )
             raise e
-        # STEP 2 — upload annotations
+        # STEP 2 - upload annotations
         frame_to_pcl_ids = {pcl_info.frame: pcl_info.id for pcl_info in pcl_infos}
         try:
             api.pointcloud_episode.annotation.append(
@@ -1033,9 +1062,9 @@ def upload_pointcloud_episode_project(
             )
             raise e
 
-        # STEP 3 — upload photo context
+        # STEP 3 - upload photo context
         img_infos = {"img_paths": [], "img_metas": []}
-        # STEP 3.1 — upload images
+        # STEP 3.1 - upload images
         pcl_to_rimg_figures: Dict[int, Dict[str, List[Dict]]] = {}
         pcl_to_hash_to_id: Dict[int, Dict[str, int]] = {}
         for pcl_info in pcl_infos:
@@ -1067,7 +1096,7 @@ def upload_pointcloud_episode_project(
             )
             raise e
 
-        # STEP 3.2 — upload images metas
+        # STEP 3.2 - upload images metas
         images_hashes_iterator = images_hashes.__iter__()
         for pcl_info in pcl_infos:
             related_items = dataset_fs.get_related_images(pcl_info.name)

supervisely/project/pointcloud_project.py

@@ -908,6 +908,25 @@ class PointcloudProject(VideoProject):
             f"Static method 'download_async()' is not supported for PointcloudProject class now."
         )
 
+    # -------------------------- #
+    # Pointcloud Data Versioning #
+    # -------------------------- #
+    @staticmethod
+    def download_bin(*args, **kwargs):
+        raise NotImplementedError("Data versioning is not supported for PointcloudProject.")
+
+    @staticmethod
+    def upload_bin(*args, **kwargs):
+        raise NotImplementedError("Data versioning is not supported for PointcloudProject.")
+
+    @staticmethod
+    def build_snapshot(*args, **kwargs):
+        raise NotImplementedError("Data versioning is not supported for PointcloudProject.")
+
+    @staticmethod
+    def restore_snapshot(*args, **kwargs):
+        raise NotImplementedError("Data versioning is not supported for PointcloudProject.")
+
 
 def download_pointcloud_project(
     api: Api,
@@ -1216,8 +1235,17 @@ def upload_pointcloud_project(
         log_progress = False
 
     key_id_map = KeyIdMap()
-    for dataset_fs in project_fs:
-        dataset = api.dataset.create(project.id, dataset_fs.name, change_name_if_conflict=True)
+    name_to_dsinfo = {}
+    for dataset_fs in sorted(project_fs, key=lambda ds: len(ds.parents)):
+        parent_name = dataset_fs.name.removesuffix(dataset_fs.short_name).rstrip("/")
+        parent_info = name_to_dsinfo.get(parent_name)
+        parent_id = None
+        if parent_info is not None:
+            parent_id = parent_info.id
+        dataset = api.dataset.create(
+            project.id, dataset_fs.short_name, change_name_if_conflict=True, parent_id=parent_id
+        )
+        name_to_dsinfo[dataset_fs.name] = dataset
 
         ds_progress = progress_cb
         if log_progress:

supervisely/project/project.py

@@ -3626,7 +3626,11 @@ class Project:
         if project_name is None:
             project_name = project_info.name
         new_project_info = api.project.create(
-            workspace_id, project_name, change_name_if_conflict=True
+            workspace_id,
+            project_name,
+            description=project_info.description,
+            change_name_if_conflict=True,
+            readme=project_info.readme,
         )
         custom_data = new_project_info.custom_data
         version_num = project_info.version.get("version", None) if project_info.version else 0
@@ -4584,6 +4588,7 @@ def upload_project(
         blob_file_infos = []
 
     for ds_fs in project_fs.datasets:
+        logger.debug(f"Processing dataset: {ds_fs.name}")
         if len(ds_fs.parents) > 0:
             parent = f"{os.path.sep}".join(ds_fs.parents)
             parent_id = dataset_map.get(parent)
@@ -4624,8 +4629,15 @@ def upload_project(
                 if os.path.isfile(path):
                     valid_indices.append(i)
                     valid_paths.append(path)
-                else:
+                elif len(project_fs.blob_files) > 0:
                     offset_indices.append(i)
+                else:
+                    if img_infos[i] is not None:
+                        logger.debug(f"Image will be uploaded by image_info: {names[i]}")
+                    else:
+                        logger.warning(
+                            f"Image and image info file not found, image will be skipped: {names[i]}"
+                        )
             img_paths = valid_paths
             ann_paths = list(filter(lambda x: os.path.isfile(x), ann_paths))
             # Create a mapping from name to index position for quick lookups

supervisely/project/project_meta.py

@@ -14,7 +14,7 @@ from supervisely.geometry.bitmap import Bitmap
 from supervisely.geometry.polygon import Polygon
 from supervisely.geometry.rectangle import Rectangle
 from supervisely.io.json import JsonSerializable
-from supervisely.project.project_settings import ProjectSettings
+from supervisely.project.project_settings import LabelingInterface, ProjectSettings
 from supervisely.project.project_type import ProjectType
 
 
@@ -288,6 +288,32 @@ class ProjectMeta(JsonSerializable):
             # Output: <class 'supervisely.project.project_settings.ProjectSettings'>
         """
         return self._project_settings
+    
+    @property
+    def labeling_interface(self) -> Optional[LabelingInterface]:
+        """
+        Get labeling interface settings of the project.
+
+        :return: Labeling interface settings
+        :rtype: :class: `LabelingInterface` or None
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            s = sly.ProjectSettings(
+                multiview_enabled=True,
+                multiview_tag_name='multi_tag',
+                multiview_is_synced=False,
+            )
+            meta = sly.ProjectMeta(project_settings=s)
+
+            labeling_interface = meta.labeling_interface
+            print(labeling_interface)
+            # Output: None
+        """
+        return self._project_settings.labeling_interface if self._project_settings else None
 
     def to_json(self) -> Dict:
         """