supervisely 6.73.274__py3-none-any.whl → 6.73.276__py3-none-any.whl

supervisely/app/widgets/custom_models_selector/custom_models_selector.py

@@ -25,6 +25,7 @@ from supervisely.app.widgets import (
 )
 from supervisely.io.fs import get_file_name_with_ext
 from supervisely.nn.artifacts.artifacts import TrainInfo
+import supervisely.io.env as sly_env
 
 WEIGHTS_DIR = "weights"
 
@@ -69,18 +70,34 @@ class CustomModelsSelector(Widget):
             # col 1 task
             self._task_id = task_id
             self._task_path = train_info.artifacts_folder
-            task_info = self._api.task.get_info_by_id(task_id)
-            self._task_date_iso = task_info["startedAt"]
-            self._task_date = self._normalize_date()
-            self._task_link = self._create_task_link()
+            try:
+                self._task_info = self._api.task.get_info_by_id(task_id)
+            except:
+                self._task_info = None
+
+            if self._task_info is not None:
+                self._task_date_iso = self._task_info["startedAt"]
+                self._task_date = self._normalize_date()
+                self._task_link = self._create_task_link()
+            else:
+                self._task_date_iso = None
+                self._task_date = None
+                self._task_link = None
             self._config_path = train_info.config_path
 
             # col 2 project
             self._training_project_name = train_info.project_name
-            project_info = self._api.project.get_info_by_name(
-                task_info["workspaceId"], self._training_project_name
+
+            workspace_id = (
+                self._task_info["workspaceId"]
+                if self._task_info
+                else sly_env.workspace_id(raise_not_found=False)
+            )
+            self._training_project_info = (
+                self._api.project.get_info_by_name(workspace_id, self._training_project_name)
+                if workspace_id
+                else None
             )
-            self._training_project_info = project_info
 
             # col 3 checkpoints
             self._checkpoints = train_info.checkpoints
@@ -175,30 +192,36 @@ class CustomModelsSelector(Widget):
                 return ""
 
         def _create_task_widget(self) -> Flexbox:
-            task_widget = Container(
-                [
-                    Text(
-                        f"<i class='zmdi zmdi-folder' style='color: #7f858e'></i> <a href='{self._task_link}'>{self._task_id}</a>",
-                        "text",
-                    ),
-                    Text(
-                        f"<span class='field-description text-muted' style='color: #7f858e'>{self._task_date}</span>",
-                        "text",
-                        font_size=13,
-                    ),
-                ],
-                gap=0,
-            )
+            if self._task_info is not None:
+                task_widget = Container(
+                    [
+                        Text(
+                            f"<i class='zmdi zmdi-folder' style='color: #7f858e'></i> <a href='{self._task_link}'>{self._task_id}</a>",
+                            "text",
+                        ),
+                        Text(
+                            f"<span class='field-description text-muted' style='color: #7f858e'>{self._task_date}</span>",
+                            "text",
+                            font_size=13,
+                        ),
+                    ],
+                    gap=0,
+                )
+            else:
+                task_widget = Text(
+                    f"<span class='field-description text-muted' style='color: #7f858e'>Task was archived (ID: '{self._task_id}')</span>",
+                    "text",
+                )
             return task_widget
 
         def _create_training_project_widget(self) -> Union[ProjectThumbnail, Text]:
-            if self.training_project_info is not None:
+            if self._training_project_info is not None:
                 training_project_widget = ProjectThumbnail(
                     self._training_project_info, remove_margins=True
                 )
             else:
                 training_project_widget = Text(
-                    f"<span class='field-description text-muted' style='color: #7f858e'>Project was deleted</span>",
+                    f"<span class='field-description text-muted' style='color: #7f858e'>Project was archived</span>",
                     "text",
                     font_size=13,
                 )
@@ -209,15 +232,11 @@ class CustomModelsSelector(Widget):
             for checkpoint_info in self._checkpoints:
                 if isinstance(checkpoint_info, dict):
                     checkpoint_selector_items.append(
-                        Select.Item(
-                            value=checkpoint_info["path"], label=checkpoint_info["name"]
-                        )
+                        Select.Item(value=checkpoint_info["path"], label=checkpoint_info["name"])
                     )
                 elif isinstance(checkpoint_info, FileInfo):
                     checkpoint_selector_items.append(
-                        Select.Item(
-                            value=checkpoint_info.path, label=checkpoint_info.name
-                        )
+                        Select.Item(value=checkpoint_info.path, label=checkpoint_info.name)
                     )
 
             checkpoint_selector = Select(items=checkpoint_selector_items)
@@ -282,9 +301,7 @@ class CustomModelsSelector(Widget):
             )
 
             file_api = FileApi(self._api)
-            self._model_path_input = Input(
-                placeholder="Path to model file in Team Files"
-            )
+            self._model_path_input = Input(placeholder="Path to model file in Team Files")
 
             @self._model_path_input.value_changed
             def change_folder(value):
@@ -322,9 +339,7 @@ class CustomModelsSelector(Widget):
 
             self.custom_tab_widgets.hide()
 
-            self.show_custom_checkpoint_path_checkbox = Checkbox(
-                "Use custom checkpoint", False
-            )
+            self.show_custom_checkpoint_path_checkbox = Checkbox("Use custom checkpoint", False)
 
             @self.show_custom_checkpoint_path_checkbox.value_changed
             def show_custom_checkpoint_path_checkbox_changed(is_checked):
@@ -399,9 +414,7 @@ class CustomModelsSelector(Widget):
         self.disable_table()
         super().disable()
 
-    def _generate_table_rows(
-        self, train_infos: List[TrainInfo]
-    ) -> Dict[str, List[ModelRow]]:
+    def _generate_table_rows(self, train_infos: List[TrainInfo]) -> Dict[str, List[ModelRow]]:
         """Method to generate table rows from remote path to training app save directory"""
 
         def process_train_info(train_info):
@@ -414,7 +427,7 @@ class CustomModelsSelector(Widget):
                 )
                 return train_info.task_type, model_row
             except Exception as e:
-                logger.warn(f"Failed to process train info: {train_info}")
+                logger.warning(f"Failed to process train info: {train_info}. Error: {repr(e)}")
                 return None, None
 
         table_rows = defaultdict(list)
@@ -448,8 +461,7 @@ class CustomModelsSelector(Widget):
         if "pose estimation" in task_types:
             sorted_tt.append("pose estimation")
         other_tasks = sorted(
-            set(task_types)
-            - set(["object detection", "instance segmentation", "pose estimation"])
+            set(task_types) - set(["object detection", "instance segmentation", "pose estimation"])
         )
         sorted_tt.extend(other_tasks)
         return sorted_tt
@@ -536,9 +548,7 @@ class CustomModelsSelector(Widget):
 
     def set_custom_checkpoint_task_type(self, task_type: str) -> None:
         if self.use_custom_checkpoint_path():
-            available_task_types = (
-                self.custom_checkpoint_task_type_selector.get_labels()
-            )
+            available_task_types = self.custom_checkpoint_task_type_selector.get_labels()
             if task_type not in available_task_types:
                 raise ValueError(f'"{task_type}" is not available task type')
             self.custom_checkpoint_task_type_selector.set_value(task_type)

supervisely/convert/__init__.py

@@ -38,7 +38,7 @@ from supervisely.convert.pointcloud.las.las_converter import LasConverter
 from supervisely.convert.pointcloud.ply.ply_converter import PlyConverter
 from supervisely.convert.pointcloud.bag.bag_converter import BagConverter
 from supervisely.convert.pointcloud.lyft.lyft_converter import LyftConverter
-
+from supervisely.convert.pointcloud.nuscenes_conv.nuscenes_converter import NuscenesConverter
 
 # Pointcloud Episodes
 from supervisely.convert.pointcloud_episodes.sly.sly_pointcloud_episodes_converter import (
@@ -46,6 +46,9 @@ from supervisely.convert.pointcloud_episodes.sly.sly_pointcloud_episodes_convert
 )
 from supervisely.convert.pointcloud_episodes.bag.bag_converter import BagEpisodesConverter
 from supervisely.convert.pointcloud_episodes.lyft.lyft_converter import LyftEpisodesConverter
+from supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_converter import (
+    NuscenesEpisodesConverter,
+)
 
 # Video
 from supervisely.convert.video.mot.mot_converter import MOTConverter

supervisely/convert/base_converter.py

@@ -55,6 +55,7 @@ class AvailablePointcloudConverters:
     PLY = "ply"
     BAG = "rosbag"
     LYFT = "lyft"
+    NUSCENES = "nuscenes"
 
 
 class AvailablePointcloudEpisodesConverters:
@@ -301,23 +302,15 @@ class BaseConverter:
             return found_formats[0]
 
     def _collect_items_if_format_not_detected(self):
-        from supervisely.convert.pointcloud_episodes.pointcloud_episodes_converter import (
-            PointcloudEpisodeConverter,
-        )
-
         only_modality_items = True
         unsupported_exts = set()
         items = []
-        is_episode = isinstance(self, PointcloudEpisodeConverter)
         for root, _, files in os.walk(self._input_data):
             for file in files:
                 full_path = os.path.join(root, file)
                 ext = get_file_ext(full_path)
                 if ext.lower() in self.allowed_exts:  # pylint: disable=no-member
-                    if is_episode:
-                        items.append(self.Item(full_path, len(items)))  # pylint: disable=no-member
-                    else:
-                        items.append(self.Item(full_path))  # pylint: disable=no-member
+                    items.append(self.Item(full_path))  # pylint: disable=no-member
                     continue
                 only_modality_items = False
                 if ext.lower() in self.unsupported_exts:

supervisely/convert/pointcloud/nuscenes_conv/nuscenes_converter.py

@@ -0,0 +1,227 @@
+import os
+from typing import Dict, Optional
+
+import supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_helper as helpers
+import supervisely.io.fs as fs
+from supervisely import PointcloudAnnotation, PointcloudObject
+from supervisely._utils import is_development
+from supervisely.annotation.obj_class import ObjClass
+from supervisely.annotation.tag_meta import TagMeta, TagValueType
+from supervisely.api.api import Api, ApiField
+from supervisely.convert.base_converter import AvailablePointcloudConverters
+from supervisely.convert.pointcloud.pointcloud_converter import PointcloudConverter
+from supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_converter import (
+    NuscenesEpisodesConverter,
+)
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.pointcloud_annotation.pointcloud_figure import PointcloudFigure
+from supervisely.pointcloud_annotation.pointcloud_object_collection import (
+    PointcloudObjectCollection,
+)
+from supervisely.pointcloud_annotation.pointcloud_tag import PointcloudTag
+from supervisely.pointcloud_annotation.pointcloud_tag_collection import (
+    PointcloudTagCollection,
+)
+from supervisely.project.project_meta import ProjectMeta
+from supervisely.sly_logger import logger
+
+
+class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
+    """Converter for NuScenes pointcloud format."""
+
+    def __init__(
+        self,
+        input_data: str,
+        labeling_interface: str,
+        upload_as_links: bool,
+        remote_files_map: Optional[Dict[str, str]] = None,
+    ):
+        super().__init__(input_data, labeling_interface, upload_as_links, remote_files_map)
+        self._nuscenes = None
+
+    def __str__(self) -> str:
+        return AvailablePointcloudConverters.NUSCENES
+
+    def to_supervisely(
+        self,
+        scene_sample,
+        meta: ProjectMeta,
+        renamed_classes: dict = {},
+        renamed_tags: dict = {},
+    ) -> PointcloudAnnotation:
+        bevbox_objs = [obj.convert_nuscenes_to_BEVBox3D() for obj in scene_sample.anns]
+        geoms = [obj.to_supervisely() for obj in scene_sample.anns]
+        attrs = [obj.attributes for obj in scene_sample.anns]
+
+        figures = []
+        objs = []
+        for label, geom, attributes in zip(bevbox_objs, geoms, attrs):
+            class_name = renamed_classes.get(label.label_class, label.label_class)
+            tag_col = None
+            if len(attributes) > 0 and all([tag_name is not None for tag_name in attributes]):
+                tag_meta_names = [renamed_tags.get(name, name) for name in attributes]
+                tag_metas = [meta.get_tag_meta(tag_meta_name) for tag_meta_name in tag_meta_names]
+                tag_col = PointcloudTagCollection([PointcloudTag(meta, None) for meta in tag_metas])
+            pcobj = PointcloudObject(meta.get_obj_class(class_name), tag_col)
+            figures.append(PointcloudFigure(pcobj, geom))
+            objs.append(pcobj)
+        return PointcloudAnnotation(PointcloudObjectCollection(objs), figures)
+
+    def upload_dataset(self, api: Api, dataset_id: int, batch_size: int = 1, log_progress=True):
+        nuscenes = self._nuscenes
+
+        tag_metas = [TagMeta(attr["name"], TagValueType.NONE) for attr in nuscenes.attribute]
+        obj_classes = []
+        for category in nuscenes.category:
+            color = nuscenes.colormap[category["name"]]
+            description = category["description"]
+            if len(description) > 255:
+                # * Trim description to fit into 255 characters limit
+                sentences = description.split(".")
+                trimmed_description = ""
+                for sentence in sentences:
+                    if len(trimmed_description) + len(sentence) + 1 > 255:
+                        break
+                    trimmed_description += sentence + "."
+                description = trimmed_description.strip()
+            obj_classes.append(ObjClass(category["name"], Cuboid3d, color, description=description))
+
+        self._meta = ProjectMeta(obj_classes, tag_metas)
+        meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
+
+        dataset_info = api.dataset.get_info_by_id(dataset_id)
+        scene_name_to_dataset = {}
+
+        scene_names = [scene["name"] for scene in nuscenes.scene]
+        scene_cnt = len(scene_names)
+        total_sample_cnt = sum([scene["nbr_samples"] for scene in nuscenes.scene])
+
+        multiple_scenes = len(scene_names) > 1
+        if multiple_scenes:
+            logger.info(f"Found {scene_cnt} scenes ({total_sample_cnt} samples) in the input data.")
+            # * Create a nested dataset for each scene
+            for name in scene_names:
+                ds = api.dataset.create(
+                    dataset_info.project_id,
+                    name,
+                    change_name_if_conflict=True,
+                    parent_id=dataset_id,
+                )
+                scene_name_to_dataset[name] = ds
+        else:
+            scene_name_to_dataset[scene_names[0]] = dataset_info
+
+        if log_progress:
+            progress, progress_cb = self.get_progress(total_sample_cnt, "Converting pointclouds...")
+        else:
+            progress_cb = None
+
+        for scene in nuscenes.scene:
+            current_dataset_id = scene_name_to_dataset[scene["name"]].id
+
+            log = nuscenes.get("log", scene["log_token"])
+            sample_token = scene["first_sample_token"]
+
+            # * Extract scene's samples
+            scene_samples = []
+            for i in range(scene["nbr_samples"]):
+                sample = nuscenes.get("sample", sample_token)
+                lidar_path, boxes, _ = nuscenes.get_sample_data(sample["data"]["LIDAR_TOP"])
+                if not os.path.exists(lidar_path):
+                    logger.warning(f'Scene "{scene["name"]}" has no LIDAR data.')
+                    continue
+
+                timestamp = sample["timestamp"]
+                anns = []
+                for box, name, inst_token in helpers.Sample.generate_boxes(nuscenes, boxes):
+                    current_instance_token = inst_token["token"]
+                    parent_token = inst_token["prev"]
+
+                    # get category, attributes and visibility
+                    ann = nuscenes.get("sample_annotation", current_instance_token)
+                    category = ann["category_name"]
+                    attributes = [
+                        nuscenes.get("attribute", attr)["name"] for attr in ann["attribute_tokens"]
+                    ]
+                    visibility = nuscenes.get("visibility", ann["visibility_token"])["level"]
+
+                    anns.append(
+                        helpers.AnnotationObject(
+                            name,
+                            box,
+                            current_instance_token,
+                            parent_token,
+                            category,
+                            attributes,
+                            visibility,
+                        )
+                    )
+
+                # get camera data
+                sample_data = nuscenes.get("sample_data", sample["data"]["LIDAR_TOP"])
+                cal_sensor = nuscenes.get(
+                    "calibrated_sensor", sample_data["calibrated_sensor_token"]
+                )
+                ego_pose = nuscenes.get("ego_pose", sample_data["ego_pose_token"])
+
+                camera_data = [
+                    helpers.CamData(nuscenes, sensor, token, cal_sensor, ego_pose)
+                    for sensor, token in sample["data"].items()
+                    if sensor.startswith("CAM")
+                ]
+                scene_samples.append(helpers.Sample(timestamp, lidar_path, anns, camera_data))
+                sample_token = sample["next"]
+
+            # * Convert and upload pointclouds w/ annotations
+            for idx, sample in enumerate(scene_samples):
+                pcd_ann = self.to_supervisely(sample, meta, renamed_classes, renamed_tags)
+
+                pcd_path = sample.convert_lidar_to_supervisely()
+                pcd_name = fs.get_file_name(pcd_path)
+                pcd_meta = {
+                    "frame": idx,
+                    "vehicle": log["vehicle"],
+                    "date": log["date_captured"],
+                    "location": log["location"],
+                    "description": scene["description"],
+                }
+                info = api.pointcloud.upload_path(current_dataset_id, pcd_name, pcd_path, pcd_meta)
+                fs.silent_remove(pcd_path)
+
+                pcd_id = info.id
+                # * Upload pointcloud annotation
+                try:
+                    api.pointcloud.annotation.append(pcd_id, pcd_ann)
+                except Exception as e:
+                    error_msg = getattr(getattr(e, "response", e), "text", str(e))
+                    logger.warning(
+                        f"Failed to upload annotation for scene: {scene['name']}. Message: {error_msg}"
+                    )
+
+                # * Upload related images
+                image_jsons = []
+                camera_names = []
+                for img_path, rimage_info in [
+                    data.get_info(sample.timestamp) for data in sample.cam_data
+                ]:
+                    img = api.pointcloud.upload_related_image(img_path)
+                    image_jsons.append(
+                        {
+                            ApiField.ENTITY_ID: pcd_id,
+                            ApiField.NAME: rimage_info[ApiField.NAME],
+                            ApiField.HASH: img,
+                            ApiField.META: rimage_info[ApiField.META],
+                        }
+                    )
+                    camera_names.append(rimage_info[ApiField.META]["deviceId"])
+                if len(image_jsons) > 0:
+                    api.pointcloud.add_related_images(image_jsons, camera_names)
+
+                if log_progress:
+                    progress_cb(1)
+
+            logger.info(f"Dataset ID:{current_dataset_id} has been successfully uploaded.")
+
+        if log_progress:
+            if is_development():
+                progress.close()

supervisely/convert/pointcloud/pointcloud_converter.py

@@ -1,5 +1,8 @@
-from typing import Optional, Tuple
+import imghdr
+import os
+from typing import List, Optional, Set, Tuple
 
+import supervisely.convert.pointcloud.sly.sly_pointcloud_helper as helpers
 from supervisely import (
     Api,
     PointcloudAnnotation,
@@ -10,8 +13,10 @@ from supervisely import (
 )
 from supervisely.api.module_api import ApiField
 from supervisely.convert.base_converter import BaseConverter
+from supervisely.io.fs import get_file_ext, get_file_name
 from supervisely.io.json import load_json_file
 from supervisely.pointcloud.pointcloud import ALLOWED_POINTCLOUD_EXTENSIONS
+from supervisely.pointcloud.pointcloud import validate_ext as validate_pcd_ext
 
 
 class PointcloudConverter(BaseConverter):
@@ -134,3 +139,49 @@ class PointcloudConverter(BaseConverter):
             if is_development():
                 progress.close()
         logger.info(f"Dataset ID:{dataset_id} has been successfully uploaded.")
+
+    def _collect_items_if_format_not_detected(self) -> Tuple[List[Item], bool, Set[str]]:
+        only_modality_items = True
+        unsupported_exts = set()
+        pcd_list, rimg_dict, rimg_ann_dict = [], {}, {}
+        used_img_ext = set()
+        for root, _, files in os.walk(self._input_data):
+            for file in files:
+                full_path = os.path.join(root, file)
+                if file in ["key_id_map.json", "meta.json"]:
+                    continue
+
+                ext = get_file_ext(full_path)
+                if ext == ".json":
+                    dir_name = os.path.basename(root)
+                    parent_dir_name = os.path.basename(os.path.dirname(root))
+                    if any(
+                        p.replace("_", " ") in ["images", "related images", "photo context"]
+                        for p in [dir_name, parent_dir_name]
+                    ) or dir_name.endswith("_pcd"):
+                        rimg_ann_dict[file] = full_path
+                elif imghdr.what(full_path):
+                    rimg_dict[file] = full_path
+                    if ext not in used_img_ext:
+                        used_img_ext.add(ext)
+                elif ext.lower() in self.allowed_exts:
+                    try:
+                        validate_pcd_ext(ext)
+                        pcd_list.append(full_path)
+                    except:
+                        pass
+                else:
+                    only_modality_items = False
+                    unsupported_exts.add(ext)
+
+        # create Items
+        items = []
+        for pcd_path in pcd_list:
+            item = self.Item(pcd_path)
+            rimg, rimg_ann = helpers.find_related_items(
+                item.name, used_img_ext, rimg_dict, rimg_ann_dict
+            )
+            if rimg is not None and rimg_ann is not None:
+                item.set_related_images((rimg, rimg_ann))
+            items.append(item)
+        return items, only_modality_items, unsupported_exts

supervisely/convert/pointcloud/sly/sly_pointcloud_converter.py

@@ -6,7 +6,7 @@ import supervisely.convert.pointcloud.sly.sly_pointcloud_helper as helpers
 from supervisely import PointcloudAnnotation, ProjectMeta, logger
 from supervisely.convert.base_converter import AvailablePointcloudConverters
 from supervisely.convert.pointcloud.pointcloud_converter import PointcloudConverter
-from supervisely.io.fs import JUNK_FILES, get_file_ext, get_file_name
+from supervisely.io.fs import get_file_ext, get_file_name
 from supervisely.io.json import load_json_file
 from supervisely.pointcloud.pointcloud import validate_ext as validate_pcd_ext
 
@@ -46,7 +46,6 @@ class SLYPointcloudConverter(PointcloudConverter):
             return False
 
     def validate_format(self) -> bool:
-        detected_ann_cnt = 0
         pcd_list, ann_dict, rimg_dict, rimg_ann_dict = [], {}, {}, {}
         used_img_ext = []
         for root, _, files in os.walk(self._input_data):
@@ -60,9 +59,7 @@ class SLYPointcloudConverter(PointcloudConverter):
                         continue
 
                 ext = get_file_ext(full_path)
-                if file in JUNK_FILES:  # add better check
-                    continue
-                elif ext in self.ann_ext:
+                if ext in self.ann_ext:
                     dir_name = os.path.basename(root)
                     parent_dir_name = os.path.basename(os.path.dirname(root))
                     if any(
@@ -83,16 +80,11 @@ class SLYPointcloudConverter(PointcloudConverter):
                     except:
                         continue
 
-        if self._meta is not None:
-            meta = self._meta
-        else:
-            meta = ProjectMeta()
-
         # create Items
         self._items = []
+        sly_ann_detected = False
         for pcd_path in pcd_list:
             name_noext = get_file_name(pcd_path)
-            ann_or_rimg_detected = False
             item = self.Item(pcd_path)
             ann_name = f"{item.name}.json"
             if ann_name not in ann_dict:
@@ -100,23 +92,18 @@ class SLYPointcloudConverter(PointcloudConverter):
             if ann_name in ann_dict:
                 ann_path = ann_dict[ann_name]
                 if self._meta is None:
-                    meta = self.generate_meta_from_annotation(ann_path, meta)
-                is_valid = self.validate_ann_file(ann_path, meta)
+                    self._meta = self.generate_meta_from_annotation(ann_path, self._meta)
+                is_valid = self.validate_ann_file(ann_path, self._meta)
                 if is_valid:
                     item.ann_data = ann_path
-                    ann_or_rimg_detected = True
+                    sly_ann_detected = True
             rimg, rimg_ann = helpers.find_related_items(
                 item.name, used_img_ext, rimg_dict, rimg_ann_dict
             )
             if rimg is not None and rimg_ann is not None:
                 item.set_related_images((rimg, rimg_ann))
-                ann_or_rimg_detected = True
-
-            if ann_or_rimg_detected:
-                detected_ann_cnt += 1
             self._items.append(item)
-        self._meta = meta
-        return detected_ann_cnt > 0
+        return sly_ann_detected
 
     def to_supervisely(
         self,
@@ -140,5 +127,5 @@ class SLYPointcloudConverter(PointcloudConverter):
                 ann_json = helpers.rename_in_json(ann_json, renamed_classes, renamed_tags)
             return PointcloudAnnotation.from_json(ann_json, meta)
         except Exception as e:
-            logger.warn(f"Failed to convert annotation: {repr(e)}")
+            logger.warning(f"Failed to convert annotation: {repr(e)}")
             return item.create_empty_annotation()

supervisely/convert/pointcloud/sly/sly_pointcloud_helper.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Union
 
 from supervisely import (
     AnyGeometry,
@@ -16,7 +16,9 @@ from supervisely.io.json import load_json_file
 SLY_ANN_KEYS = ["figures", "objects", "tags"]
 
 
-def get_meta_from_annotation(ann_path: str, meta: ProjectMeta) -> ProjectMeta:
+def get_meta_from_annotation(ann_path: str, meta: Union[ProjectMeta, None]) -> ProjectMeta:
+    if meta is None:
+        meta = ProjectMeta()
     ann_json = load_json_file(ann_path)
     if "annotation" in ann_json:
         ann_json = ann_json["annotation"]