supervisely 6.73.262__py3-none-any.whl → 6.73.264__py3-none-any.whl

supervisely/__init__.py

@@ -309,4 +309,4 @@ except Exception as e:
 # If new changes in Supervisely Python SDK require upgrade of the Supervisely instance
 # set a new value for the environment variable MINIMUM_INSTANCE_VERSION_FOR_SDK, otherwise
 # users can face compatibility issues, if the instance version is lower than the SDK version.
-os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.12"
+os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.17"

supervisely/api/app_api.py

@@ -1212,17 +1212,80 @@ class AppApi(TaskApi):
 
     def get_list(
         self,
-        team_id,
-        filter=None,
-        context=None,
-        repository_key=None,
-        show_disabled=False,
-        integrated_into=None,
-        session_tags=None,
-        only_running=False,
-        with_shared=True,
+        team_id: int,
+        filter: Optional[List[dict]] = None,
+        context: Optional[List[str]] = None,
+        repository_key: Optional[str] = None,
+        show_disabled: bool = False,
+        integrated_into: Optional[List[str]] = None,
+        session_tags: Optional[List[str]] = None,
+        only_running: bool = False,
+        with_shared: bool = True,
+        force_all_sessions: bool = True,
     ) -> List[AppInfo]:
-        """get_list"""
+        """
+        Get list of applications for the specified team.
+
+        :param team_id: team id
+        :type team_id: int
+        :param filter: list of filters
+        :type filter: Optional[List[dict]]
+        :param context: list of application contexts
+        :type context: Optional[List[str]]
+        :param repository_key: repository key
+        :type repository_key: Optional[str]
+        :param show_disabled: show disabled applications
+        :type show_disabled: bool
+        :param integrated_into: destination of the application.
+                    Available values: "panel", "files", "standalone", "data_commander",
+                                    "image_annotation_tool", "video_annotation_tool",
+                                    "dicom_annotation_tool", "pointcloud_annotation_tool"
+        :type integrated_into: Optional[List[str]]
+        :param session_tags: list of session tags
+        :type session_tags: Optional[List[str]]
+        :param only_running: show only running applications (status is one of "queued"/"consumed"/"started"/"deployed")
+        :type only_running: bool
+        :param with_shared: include shared applications
+        :type with_shared: bool
+        :param force_all_sessions: force to get all sessions (tasks) for each application.
+                                Works only if only_running is False.
+                                Note that it can be a long operation.
+        :type force_all_sessions: bool
+
+        :return: list of applications
+        :rtype: List[AppInfo]
+
+
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            team_id = 447
+
+            # Get list of all applications (including all tasks in `tasks` field)
+            apps = api.app.get_list(team_id=team_id)
+
+            # Get list of all applications (only running tasks included in `tasks` field)
+            apps = api.app.get_list(team_id=team_id, force_all_sessions=False)
+
+            # Get list of only running applications
+            apps = api.app.get_list(team_id=team_id, only_running=True)
+
+            # Get list of applications with specific filters
+            filter = [{"field": "moduleId", "operator": "=", "value": 428}]
+            apps = api.app.get_list(team_id=team_id, filter=filter)
+        """
+
+        if only_running is True:
+            # no need to get all sessions if only running sessions are requested
+            # (`force_all_sessions` has higher priority than only_running)
+            force_all_sessions = False
 
         return self.get_list_all_pages(
             method="apps.list",
@@ -1240,6 +1303,7 @@ class AppApi(TaskApi):
                 "onlyRunning": only_running,
                 "showDisabled": show_disabled,
                 "withShared": with_shared,
+                "forceAllSessions": force_all_sessions,
             },
         )
 
@@ -1479,49 +1543,105 @@ class AppApi(TaskApi):
 
     def get_sessions(
         self,
-        team_id,
-        module_id,
-        # only_running=False,
-        show_disabled=False,
-        session_name=None,
-        statuses: List[TaskApi.Status] = None,
+        team_id: int,
+        module_id: int,
+        show_disabled: bool = False,
+        session_name: Optional[str] = None,
+        statuses: Optional[List[TaskApi.Status]] = None,
+        with_shared: bool = False,
     ) -> List[SessionInfo]:
-        infos_json = self.get_list_all_pages(
-            method="apps.list",
-            data={
-                "teamId": team_id,
-                "filter": [{"field": "moduleId", "operator": "=", "value": module_id}],
-                # "onlyRunning": only_running,
-                "showDisabled": show_disabled,
-            },
-            convert_json_info_cb=lambda x: x,
-            # validate_total=False,
+        """
+        Get list of sessions (tasks) for the specified team and module.
+
+        :param team_id: team id
+        :type team_id: int
+        :param module_id: application module id
+        :type module_id: int
+        :param show_disabled: show disabled applications
+        :type show_disabled: bool
+        :param session_name: session name to filter sessions
+        :type session_name: Optional[str]
+        :param statuses: list of statuses to filter sessions
+        :type statuses: Optional[List[TaskApi.Status]]
+        :param with_shared: include shared application sessions
+        :type with_shared: bool
+
+        :return: list of sessions
+        :rtype: List[SessionInfo]
+
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+
+            team_id = 447
+            module_id = 428
+
+            # Get list of all sessions for the specified team and module ID
+            sessions = api.app.get_sessions(team_id, module_id)
+
+            # Get list of sessions with specific statuses
+            from supervisely.api.task_api import TaskApi
+
+            statuses = [TaskApi.Status.STARTED]
+            sessions = api.app.get_sessions(team_id, module_id, statuses=statuses)
+        """
+
+        infos_json = self.get_list(
+            team_id,
+            filter=[
+                {
+                    ApiField.FIELD: ApiField.MODULE_ID,
+                    ApiField.OPERATOR: "=",
+                    ApiField.VALUE: module_id,
+                }
+            ],
+            with_shared=with_shared,
+            only_running=False,
+            force_all_sessions=False,
         )
-        if len(infos_json) == 0:
-            # raise KeyError(f"App [module_id = {module_id}] not found in team {team_id}")
-            return []
-        if len(infos_json) > 1:
+        if len(infos_json) > 1 and with_shared is False:
             raise KeyError(
                 f"Apps list in team is broken: app [module_id = {module_id}] added to team {team_id} multiple times"
             )
-        dev_tasks = []
-        sessions = infos_json[0]["tasks"]
-
-        str_statuses = []
-        if statuses is not None:
-            for s in statuses:
-                str_statuses.append(str(s))
-
+        sessions = []
+        for app in infos_json:
+            data = {
+                ApiField.TEAM_ID: team_id,
+                ApiField.APP_ID: app.id,
+                # ApiField.ONLY_RUNNING: False,
+                ApiField.SHOW_DISABLED: show_disabled,
+                ApiField.WITH_SHARED: with_shared,
+                ApiField.SORT: ApiField.STARTED_AT,
+                ApiField.SORT_ORDER: "desc",
+            }
+            if statuses is not None:
+                data[ApiField.FILTER] = [
+                    {
+                        ApiField.FIELD: ApiField.STATUS,
+                        ApiField.OPERATOR: "in",
+                        ApiField.VALUE: [str(s) for s in statuses],
+                    }
+                ]
+            sessions.extend(
+                self.get_list_all_pages(
+                    method="apps.tasks.list",
+                    data=data,
+                    convert_json_info_cb=lambda x: x,
+                )
+            )
+        session_infos = []
         for session in sessions:
-            to_add = True
             if session_name is not None and session["meta"]["name"] != session_name:
-                to_add = False
-            if statuses is not None and session["status"] not in str_statuses:
-                to_add = False
-            if to_add is True:
-                session["moduleId"] = module_id
-                dev_tasks.append(SessionInfo.from_json(session))
-        return dev_tasks
+                continue
+            session["moduleId"] = module_id
+            session_infos.append(SessionInfo.from_json(session))
+        return session_infos
 
     def start(
         self,

supervisely/api/module_api.py

@@ -596,6 +596,12 @@ class ApiField:
     """"""
     CLEAR_LOCAL_DATA_SOURCE = "clearLocalDataSource"
     """"""
+    ONLY_RUNNING = "onlyRunning"
+    """"""
+    SHOW_DISABLED = "showDisabled"
+    """"""
+    WITH_SHARED = "withShared"
+    """"""
 
 
 def _get_single_item(items):

supervisely/convert/__init__.py

@@ -37,6 +37,7 @@ from supervisely.convert.pointcloud.sly.sly_pointcloud_converter import SLYPoint
 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
 
 
 # Pointcloud Episodes
@@ -44,6 +45,7 @@ from supervisely.convert.pointcloud_episodes.sly.sly_pointcloud_episodes_convert
     SLYPointcloudEpisodesConverter,
 )
 from supervisely.convert.pointcloud_episodes.bag.bag_converter import BagEpisodesConverter
+from supervisely.convert.pointcloud_episodes.lyft.lyft_converter import LyftEpisodesConverter
 
 # Video
 from supervisely.convert.video.mot.mot_converter import MOTConverter

supervisely/convert/base_converter.py

@@ -54,11 +54,13 @@ class AvailablePointcloudConverters:
     LAS = "las/laz"
     PLY = "ply"
     BAG = "rosbag"
+    LYFT = "lyft"
 
 
 class AvailablePointcloudEpisodesConverters:
     SLY = "supervisely"
     BAG = "rosbag"
+    LYFT = "lyft"
 
 
 class AvailableVolumeConverters:

supervisely/convert/image/image_helper.py

@@ -15,6 +15,7 @@ from supervisely.io.fs import (
     silent_remove,
 )
 
+Image.MAX_IMAGE_PIXELS = None
 EXT_TO_CONVERT = [".heic", ".avif", ".heif", ".jfif"]
 
 

supervisely/convert/pointcloud/lyft/lyft_converter.py

@@ -0,0 +1,287 @@
+import numpy as np
+from pathlib import Path
+from typing import Dict, Optional
+
+from supervisely import (
+    Api,
+    ObjClass,
+    PointcloudAnnotation,
+    ProjectMeta,
+    logger,
+    is_development,
+    Progress,
+    PointcloudObject,
+    TagMeta,
+    TagValueType,
+)
+from supervisely.io import fs
+from supervisely.convert.base_converter import AvailablePointcloudConverters
+from supervisely.convert.pointcloud.pointcloud_converter import PointcloudConverter
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.convert.pointcloud.lyft import lyft_helper
+from supervisely.api.api import ApiField
+from datetime import datetime
+from supervisely import TinyTimer
+from supervisely.pointcloud_annotation.pointcloud_annotation import (
+    PointcloudFigure,
+    PointcloudObjectCollection,
+    PointcloudTagCollection,
+)
+from supervisely.pointcloud_annotation.pointcloud_tag import PointcloudTag
+
+
+class LyftConverter(PointcloudConverter):
+    class Item(PointcloudConverter.Item):
+
+        def __init__(
+            self,
+            item_path,
+            ann_data: str = None,
+            related_images: list = None,
+            custom_data: dict = None,
+            scene_name: str = None,
+        ):
+            super().__init__(item_path, ann_data, related_images, custom_data)
+            self._type = "point_cloud"
+            self._scene_name = scene_name
+
+    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._is_pcd_episode = False
+        self._lyft = None
+
+    def __str__(self) -> str:
+        return AvailablePointcloudConverters.LYFT
+
+    @property
+    def key_file_ext(self) -> str:
+        return ".bin"
+
+    def validate_format(self) -> bool:
+        try:
+            from lyft_dataset_sdk.lyftdataset import LyftDataset as Lyft
+        except ImportError:
+            logger.warn(
+                'Install "lyft_dataset_sdk" python package to import datasets in LYFT format.'
+            )
+            return False
+
+        def filter_fn(path):
+            return all([(Path(path) / name).exists() for name in lyft_helper.FOLDER_NAMES])
+
+        input_paths = [d for d in fs.dirs_filter(self._input_data, filter_fn)]
+        if len(input_paths) == 0:
+            return False
+        input_path = input_paths[0]
+
+        lidar_dir = input_path + "/lidar/"
+        json_dir = input_path + "/data/"
+        if lyft_helper.validate_ann_dir(json_dir) is False:
+            return False
+
+        bin_files = fs.list_files_recursively(
+            lidar_dir, [self.key_file_ext], ignore_valid_extensions_case=True
+        )
+
+        if len(bin_files) == 0:
+            return False
+
+        # check if pointclouds have 5 columns (x, y, z, intensity, ring)
+        pointcloud = np.fromfile(bin_files[0], dtype=np.float32)
+        if pointcloud.shape[0] % 5 != 0:
+            return False
+
+        try:
+            t = TinyTimer()
+            lyft = Lyft(data_path=input_path, json_path=json_dir, verbose=False)
+            self._lyft: Lyft = lyft
+            logger.info(f"LyftDataset initialization took {t.get_sec():.2f} sec")
+        except Exception as e:
+            logger.info(f"Failed to initialize LyftDataset: {e}")
+            return False
+
+        t = TinyTimer()
+        progress = Progress(f"Extracting annotations from available scenes...")
+        # i = 0 # for debug
+        for scene in lyft_helper.get_available_scenes(lyft):
+            scene_name = scene["name"]
+            sample_datas = lyft_helper.extract_data_from_scene(lyft, scene)
+            if sample_datas is None:
+                logger.warning(f"Failed to extract sample data from scene: {scene['name']}.")
+                continue
+            for sample_data in sample_datas:
+                item_path = sample_data["lidar_path"]
+                ann_data = sample_data["ann_data"]
+                related_images = lyft_helper.get_related_images(ann_data)
+                custom_data = sample_data.get("custom_data", {})
+                item = self.Item(item_path, ann_data, related_images, custom_data, scene_name)
+                self._items.append(item)
+            progress.iter_done_report()
+            # i += 1
+            # if i == 2:
+            #     break
+        t = t.get_sec()
+        logger.info(
+            f"Lyft annotation extraction took {t:.2f} sec ({(t / self.items_count):.3f} sec per sample)"
+        )
+
+        return self.items_count > 0
+
+    def to_supervisely(
+        self,
+        item: PointcloudConverter.Item,
+        meta: ProjectMeta,
+        renamed_classes: dict = {},
+        renamed_tags: dict = {},
+    ) -> PointcloudAnnotation:
+        """
+        Converts a point cloud item and its annotations to the supervisely formats.
+
+        Args:
+            item (PointcloudConverter.Item): The point cloud item to convert.
+            meta (ProjectMeta): The project meta.
+
+        Returns:
+            PointcloudAnnotation: The converted point cloud annotation.
+        """
+        import open3d as o3d  # pylint: disable=import-error
+
+        if getattr(item, "ann_data", None) is None:
+            return PointcloudAnnotation()
+
+        data = item.ann_data
+
+        # * Convert annotation to json
+        boxes = data["gt_boxes"]
+        names = data["names"]
+
+        objects = []
+        for name, box in zip(names, boxes):
+            center = [float(box[0]), float(box[1]), float(box[2])]
+            size = [float(box[3]), float(box[5]), float(box[4])]
+            ry = float(box[6])
+
+            yaw = ry - np.pi
+            yaw = yaw - np.floor(yaw / (2 * np.pi) + 0.5) * 2 * np.pi
+            world_cam = None
+            objects.append(o3d.ml.datasets.utils.BEVBox3D(center, size, yaw, name, -1.0, world_cam))
+            objects[-1].yaw = ry
+
+        geoms = [lyft_helper._convert_BEVBox3D_to_geometry(box) for box in objects]
+
+        figures = []
+        objs = []
+        for l, geometry, token in zip(
+            objects, geoms, data["instance_tokens"]
+        ):  # by object in point cloud
+            class_name = renamed_classes.get(l.label_class, l.label_class)
+            tag_names = [
+                self._lyft.get("attribute", attr_token).get("name", None)
+                for attr_token in token["attribute_tokens"]
+            ]
+            tag_col = None
+            if len(tag_names) > 0 and all([tag_name is not None for tag_name in tag_names]):
+                tag_meta_names = [renamed_tags.get(name, name) for name in tag_names]
+                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, geometry))
+            objs.append(pcobj)
+        return PointcloudAnnotation(PointcloudObjectCollection(objs), figures)
+
+    def upload_dataset(self, api: Api, dataset_id: int, batch_size: int = 1, log_progress=True):
+        unique_names = {name for item in self._items for name in item.ann_data["names"]}
+        tag_names = {tag["name"] for tag in self._lyft.attribute}
+        self._meta = ProjectMeta(
+            [ObjClass(name, Cuboid3d) for name in unique_names],
+            [TagMeta(tag, TagValueType.NONE) for tag in tag_names],
+        )
+        meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
+
+        scene_names = set([item._scene_name for item in self._items])
+        dataset_info = api.dataset.get_info_by_id(dataset_id)
+        scene_name_to_dataset = {}
+
+        multiple_scenes = len(scene_names) > 1
+        if multiple_scenes:
+            logger.info(
+                f"Found {len(scene_names)} scenes ({self.items_count} pointclouds) 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[list(scene_names)[0]] = dataset_info
+
+        if log_progress:
+            progress, progress_cb = self.get_progress(self.items_count, "Converting pointclouds...")
+        else:
+            progress_cb = None
+
+        for item in self._items:
+            # * Get the current dataset for the scene
+            current_dataset = scene_name_to_dataset.get(item._scene_name, None)
+            if current_dataset is None:
+                raise RuntimeError(f"Dataset not found for scene name: {item._scene_name}")
+            current_dataset_id = current_dataset.id
+
+            # * Convert timestamp to ISO format
+            iso_time = datetime.utcfromtimestamp(item.ann_data["timestamp"] / 1e6).isoformat() + "Z"
+            item.ann_data["timestamp"] = iso_time
+
+            # * Convert pointcloud from ".bin" to ".pcd"
+            pcd_path = str(Path(item.path).with_suffix(".pcd"))
+            if fs.file_exists(pcd_path):
+                logger.warning(f"Overwriting file with path: {pcd_path}")
+            lyft_helper.convert_bin_to_pcd(item.path, pcd_path)
+
+            # * Upload pointcloud
+            pcd_name = fs.get_file_name(pcd_path)
+            info = api.pointcloud.upload_path(current_dataset_id, pcd_name, pcd_path, {})
+            pcd_id = info.id
+
+            # * Convert annotation and upload
+            ann = self.to_supervisely(item, meta, renamed_classes, renamed_tags)
+            api.pointcloud.annotation.append(pcd_id, ann)
+
+            # * Upload related images
+            image_jsons = []
+            camera_names = []
+            for img_path, rimage_info in lyft_helper.generate_rimage_infos(
+                item._related_images, item.ann_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)
+
+            # * Clean up
+            fs.silent_remove(pcd_path)
+            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/lyft/lyft_helper.py

@@ -0,0 +1,231 @@
+import os
+from typing import List, Tuple
+import numpy as np
+from supervisely import logger, fs
+from supervisely.geometry.cuboid_3d import Cuboid3d, Vector3d
+
+TABLE_NAMES = [
+    "category",
+    "attribute",
+    "visibility",
+    "instance",
+    "sensor",
+    "calibrated_sensor",
+    "ego_pose",
+    "log",
+    "scene",
+    "sample",
+    "sample_data",
+    "sample_annotation",
+    "map",
+]
+FOLDER_NAMES = ["data", "lidar", "images", "maps"]
+
+
+def get_available_scenes(lyft):
+    for scene in lyft.scene:
+        token = scene["token"]
+        scene_rec = lyft.get("scene", token)
+        sample_rec = lyft.get("sample", scene_rec["first_sample_token"])
+        sample_data = lyft.get("sample_data", sample_rec["data"]["LIDAR_TOP"])
+
+        lidar_path, boxes, _ = lyft.get_sample_data(sample_data["token"])
+        if not os.path.exists(str(lidar_path)):
+            continue
+        yield scene
+
+
+def extract_data_from_scene(lyft, scene):
+    try:
+        from pyquaternion import Quaternion
+        from lyft_dataset_sdk.utils.geometry_utils import transform_matrix
+    except ImportError as ie:
+        logger.warn(f"Lazy import failed. Error: {ie}")
+        return
+
+    new_token = scene["first_sample_token"]
+    dataset_data = []
+    num_samples = scene["nbr_samples"]
+    for i in range(num_samples):
+        my_sample = lyft.get("sample", new_token)
+
+        data = {}
+        data["ann_data"] = {}
+        data["ann_data"]["timestamp"] = my_sample["timestamp"]
+        data["custom_data"] = lyft.get("log", scene["log_token"])
+
+        sensor_token = my_sample["data"]["LIDAR_TOP"]
+        lidar_path, boxes, _ = lyft.get_sample_data(sensor_token)
+        if not os.path.exists(str(lidar_path)):
+            logger.debug(f"Skipping sample {new_token} - lidar file doesn't exist")
+            continue
+        data["lidar_path"] = str(lidar_path)
+
+        sd_record_lid = lyft.get("sample_data", sensor_token)
+        cs_record_lid = lyft.get("calibrated_sensor", sd_record_lid["calibrated_sensor_token"])
+        ego_record_lid = lyft.get("ego_pose", sd_record_lid["ego_pose_token"])
+
+        locs = np.array([b.center for b in boxes]).reshape(-1, 3)
+        dims = np.array([b.wlh for b in boxes]).reshape(-1, 3)
+        rots = np.array([b.orientation.yaw_pitch_roll[0] for b in boxes]).reshape(-1, 1)
+
+        gt_boxes = np.concatenate([locs, dims, -rots + np.pi / 2], axis=1)
+        names = np.array([b.name for b in boxes])
+        data["ann_data"]["names"] = names
+        data["ann_data"]["gt_boxes"] = gt_boxes
+        instance_tokens = [lyft.get("sample_annotation", box.token) for box in boxes]
+        data["ann_data"]["instance_tokens"] = instance_tokens
+
+        for sensor, sensor_token in my_sample["data"].items():
+            if "CAM" in sensor:
+                img_path, boxes, cam_intrinsic = lyft.get_sample_data(sensor_token)
+                if not os.path.exists(img_path):
+                    logger.debug(f"pass {sensor} - image doesn't exist")
+                    continue
+                data["ann_data"][sensor] = str(img_path)
+
+                sd_record_cam = lyft.get("sample_data", sensor_token)
+                cs_record_cam = lyft.get(
+                    "calibrated_sensor", sd_record_cam["calibrated_sensor_token"]
+                )
+                ego_record_cam = lyft.get("ego_pose", sd_record_cam["ego_pose_token"])
+                cam_height = sd_record_cam["height"]
+                cam_width = sd_record_cam["width"]
+
+                lid_to_ego = transform_matrix(
+                    cs_record_lid["translation"],
+                    Quaternion(cs_record_lid["rotation"]),
+                    inverse=False,
+                )
+                lid_ego_to_world = transform_matrix(
+                    ego_record_lid["translation"],
+                    Quaternion(ego_record_lid["rotation"]),
+                    inverse=False,
+                )
+                world_to_cam_ego = transform_matrix(
+                    ego_record_cam["translation"],
+                    Quaternion(ego_record_cam["rotation"]),
+                    inverse=True,
+                )
+                ego_to_cam = transform_matrix(
+                    cs_record_cam["translation"],
+                    Quaternion(cs_record_cam["rotation"]),
+                    inverse=True,
+                )
+
+                velo_to_cam = np.dot(
+                    ego_to_cam, np.dot(world_to_cam_ego, np.dot(lid_ego_to_world, lid_to_ego))
+                )
+                velo_to_cam_rot = velo_to_cam[:3, :3]
+                velo_to_cam_trans = velo_to_cam[:3, 3]
+
+                data["ann_data"][f"{sensor}_extrinsic"] = np.hstack(
+                    (velo_to_cam_rot, velo_to_cam_trans.reshape(3, 1))
+                )
+                data["ann_data"][f"{sensor}_intrinsic"] = np.asarray(
+                    cs_record_cam["camera_intrinsic"]
+                )
+                data["ann_data"][f"{sensor}_imsize"] = (cam_width, cam_height)
+            else:
+                logger.debug(f"pass {sensor} - isn't a camera")
+        dataset_data.append(data)
+
+        new_token = my_sample.get("next")
+        if not new_token:
+            break
+
+    return dataset_data
+
+
+def generate_rimage_infos(related_images: List[Tuple[str, str]], ann_data):
+    sensors_to_skip = ["_intrinsic", "_extrinsic", "_imsize"]
+    for sensor, image_path in related_images:
+        if not any([sensor.endswith(s) for s in sensors_to_skip]):
+            image_name = fs.get_file_name_with_ext(image_path)
+            sly_path_img = os.path.join(os.path.dirname(image_path), image_name)
+            img_info = {
+                "name": image_name,
+                "meta": {
+                    "deviceId": sensor,
+                    "timestamp": ann_data["timestamp"],
+                    "sensorsData": {
+                        "extrinsicMatrix": list(
+                            ann_data[f"{sensor}_extrinsic"].flatten().astype(float)
+                        ),
+                        "intrinsicMatrix": list(
+                            ann_data[f"{sensor}_intrinsic"].flatten().astype(float)
+                        ),
+                    },
+                },
+            }
+            yield sly_path_img, img_info
+
+
+def _convert_BEVBox3D_to_geometry(box):
+    bbox = box.to_xyzwhlr()
+    dim = bbox[[3, 5, 4]]
+    pos = bbox[:3] + [0, 0, dim[1] / 2]
+    yaw = bbox[-1]
+    position = Vector3d(float(pos[0]), float(pos[1]), float(pos[2]))
+    rotation = Vector3d(0, 0, float(-yaw))
+
+    dimension = Vector3d(float(dim[0]), float(dim[2]), float(dim[1]))
+    geometry = Cuboid3d(position, rotation, dimension)
+    return geometry
+
+
+def convert_bin_to_pcd(bin_file, save_filepath):
+    import open3d as o3d  # pylint: disable=import-error
+
+    b = np.fromfile(bin_file, dtype=np.float32).reshape(-1, 5)
+    points = b[:, 0:3]
+    intensity = b[:, 3]
+    ring_index = b[:, 4]
+    intensity_fake_rgb = np.zeros((intensity.shape[0], 3))
+    intensity_fake_rgb[:, 0] = (
+        intensity  # red The intensity measures the reflectivity of the objects
+    )
+    intensity_fake_rgb[:, 1] = (
+        ring_index  # green ring index is the index of the laser ranging from 0 to 31
+    )
+
+    pc = o3d.geometry.PointCloud(o3d.utility.Vector3dVector(points))
+    pc.colors = o3d.utility.Vector3dVector(intensity_fake_rgb)
+    o3d.io.write_point_cloud(save_filepath, pc)
+
+
+def get_related_images(ann_data):
+    # sensors_to_skip = ["_intrinsic", "_extrinsic", "_imsize"]
+    # return [
+    #     (sensor, img_path)
+    #     for sensor, img_path in ann_data.items()
+    #     if "CAM" in sensor and not any([sensor.endswith(s) for s in sensors_to_skip])
+    # ]
+    return [(sensor, img_path) for sensor, img_path in ann_data.items() if "CAM" in sensor]
+
+
+def validate_ann_dir(ann_dir):
+    if any([not fs.file_exists(f"{ann_dir}/{d}.json") for d in TABLE_NAMES]):
+        return False
+    return True
+
+
+def lyft_annotation_to_BEVBox3D(data):
+    import open3d as o3d  # pylint: disable=import-error
+
+    boxes = data["gt_boxes"]
+    names = data["names"]
+
+    objects = []
+    for name, box in zip(names, boxes):
+        center = [float(box[0]), float(box[1]), float(box[2])]
+        size = [float(box[3]), float(box[5]), float(box[4])]
+        ry = float(box[6])
+
+        yaw = ry - np.pi
+        yaw = yaw - np.floor(yaw / (2 * np.pi) + 0.5) * 2 * np.pi
+        world_cam = None
+        objects.append(o3d.ml.datasets.utils.BEVBox3D(center, size, yaw, name, -1.0, world_cam))
+        objects[-1].yaw = ry
+
+    return objects

supervisely/convert/pointcloud_episodes/lyft/lyft_converter.py

@@ -0,0 +1,244 @@
+from typing import Dict, Optional, Union
+
+from supervisely.convert.base_converter import AvailablePointcloudEpisodesConverters
+from supervisely.convert.pointcloud.lyft.lyft_converter import LyftConverter
+from supervisely.convert.pointcloud_episodes.pointcloud_episodes_converter import (
+    PointcloudEpisodeConverter,
+)
+from supervisely.pointcloud_annotation.pointcloud_episode_annotation import (
+    PointcloudEpisodeAnnotation,
+    PointcloudEpisodeObjectCollection,
+    PointcloudEpisodeFrameCollection,
+    PointcloudEpisodeTagCollection,
+    PointcloudFigure,
+)
+from supervisely.pointcloud_annotation.pointcloud_episode_tag import (
+    PointcloudEpisodeTag,
+)
+from supervisely.project.project_settings import LabelingInterface
+
+from pathlib import Path
+from supervisely import (
+    Api,
+    ObjClass,
+    ProjectMeta,
+    logger,
+    is_development,
+    PointcloudObject,
+    PointcloudEpisodeObject,
+    PointcloudFigure,
+    PointcloudEpisodeFrame,
+    TagMeta,
+    TagValueType,
+    VideoTagCollection,
+    VideoTag,
+)
+from supervisely.io import fs
+from supervisely.convert.pointcloud.lyft import lyft_helper
+from supervisely.api.api import ApiField
+from datetime import datetime
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from collections import defaultdict
+
+
+class LyftEpisodesConverter(LyftConverter, PointcloudEpisodeConverter):
+    """Converter for LYFT pointcloud episodes format."""
+
+    def __init__(
+        self,
+        input_data: str,
+        labeling_interface: Optional[Union[LabelingInterface, 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._type = "point_cloud_episode"
+        self._is_pcd_episode = True
+
+    def __str__(self) -> str:
+        return AvailablePointcloudEpisodesConverters.LYFT
+
+    def to_supervisely(
+        self,
+        items,
+        meta: ProjectMeta,
+        renamed_classes: dict = {},
+        renamed_tags: dict = {},
+    ):
+        lyft = self._lyft
+
+        scene_name_to_pcd_ep_ann = {}
+        # * Group items by scene name
+        scene_name_to_items = defaultdict(list)
+        for item in items:
+            scene_name_to_items[item._scene_name].append(item)
+
+        # * Iterate over each scene
+        for scene_name, items in scene_name_to_items.items():
+            token_to_obj = {}
+            frames = []
+            tags = []  # todo tags that belong to the whole scene if any
+            # * Iterate over each sample in the scene
+            for i, item in enumerate(items):
+                ann = item.ann_data
+                objs = lyft_helper.lyft_annotation_to_BEVBox3D(ann)
+                figures = []
+                for obj, instance_token in zip(objs, ann["instance_tokens"]):
+                    parent_object = None
+                    parent_obj_token = instance_token["prev"]
+                    if parent_obj_token == "":
+                        # * Create a new object
+                        class_name = instance_token["category_name"]
+                        obj_class_name = renamed_classes.get(class_name, class_name)
+                        obj_class = meta.get_obj_class(obj_class_name)
+
+                        # # * Get tags for the object
+                        # tag_names = [
+                        #     lyft.get("attribute", attr_token).get("name", None)
+                        #     for attr_token in instance_token["attribute_tokens"]
+                        # ]
+                        # if len(tag_names) > 0 and all(
+                        #     [tag_name is not None for tag_name in tag_names]
+                        # ):
+                        #     tags = [TagMeta(tag_name, TagValueType.NONE) for tag_name in tag_names]
+                        #     tag_meta_names = [renamed_tags.get(name, name) for name in tag_names]
+                        #     tag_metas = [
+                        #         meta.get_tag_meta(tag_meta_name) for tag_meta_name in tag_meta_names
+                        #     ]
+                        #     obj_tags = PointcloudEpisodeTagCollection(
+                        #         [PointcloudEpisodeTag(tag_meta, None) for tag_meta in tag_metas]
+                        #     )  # todo: implement after fixing
+                        obj_tags = None
+                        pcd_ep_obj = PointcloudEpisodeObject(obj_class, obj_tags)
+                        # * Assign the object to the starting token
+                        token_to_obj[instance_token["token"]] = pcd_ep_obj
+                        parent_object = pcd_ep_obj
+                    else:
+                        # * -> Figure has a parent object, get it
+                        token_to_obj[instance_token["token"]] = token_to_obj[parent_obj_token]
+                        parent_object = token_to_obj[parent_obj_token]
+
+                    geom = lyft_helper._convert_BEVBox3D_to_geometry(obj)
+                    pcd_figure = PointcloudFigure(parent_object, geom, i)
+                    figures.append(pcd_figure)
+                frame = PointcloudEpisodeFrame(i, figures)
+                frames.append(frame)
+            tag_collection = PointcloudEpisodeTagCollection(tags) if len(tags) > 0 else None
+            pcd_ep_ann = PointcloudEpisodeAnnotation(
+                len(frames),
+                PointcloudEpisodeObjectCollection(list(set(token_to_obj.values()))),
+                PointcloudEpisodeFrameCollection(frames),
+                tag_collection,
+            )
+            scene_name_to_pcd_ep_ann[scene_name] = pcd_ep_ann
+        return scene_name_to_pcd_ep_ann
+
+    def upload_dataset(self, api: Api, dataset_id: int, batch_size: int = 1, log_progress=True):
+        unique_names = {name for item in self._items for name in item.ann_data["names"]}
+        tag_names = {tag["name"] for tag in self._lyft.attribute}
+        self._meta = ProjectMeta(
+            [ObjClass(name, Cuboid3d) for name in unique_names],
+            [TagMeta(tag, TagValueType.NONE) for tag in tag_names],
+        )
+        meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
+
+        scene_names = set([item._scene_name for item in self._items])
+
+        dataset_info = api.dataset.get_info_by_id(dataset_id)
+        scene_name_to_dataset = {}
+
+        multiple_scenes = len(scene_names) > 1
+        if multiple_scenes:
+            logger.info(
+                f"Found {len(scene_names)} scenes ({self.items_count} pointclouds) 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[list(scene_names)[0]] = dataset_info
+
+        if log_progress:
+            progress, progress_cb = self.get_progress(self.items_count, "Converting pointclouds...")
+        else:
+            progress_cb = None
+
+        scene_name_to_ann = self.to_supervisely(self._items, meta, renamed_classes, renamed_tags)
+        scene_name_to_item = defaultdict(list)
+        for item in self._items:
+            scene_name_to_item[item._scene_name].append(item)
+
+        for scene, items in scene_name_to_item.items():
+            # * Get the annotation for the scene
+            ann_episode = scene_name_to_ann[scene]
+            current_dataset_id = scene_name_to_dataset[item._scene_name].id
+            frame_to_pointcloud_ids = {}
+            for idx, item in enumerate(items):
+                # * Convert timestamp to ISO format
+                iso_time = (
+                    datetime.utcfromtimestamp(item.ann_data["timestamp"] / 1e6).isoformat() + "Z"
+                )
+                item.ann_data["timestamp"] = iso_time
+
+                # * Convert pointcloud from ".bin" to ".pcd"
+                pcd_path = str(Path(item.path).with_suffix(".pcd"))
+                if fs.file_exists(pcd_path):
+                    logger.warning(f"Overwriting file with path: {pcd_path}")
+                lyft_helper.convert_bin_to_pcd(item.path, pcd_path)
+
+                # * Upload pointcloud
+                pcd_meta = {}
+                pcd_meta["frame"] = idx
+
+                pcd_name = fs.get_file_name(pcd_path)
+                info = api.pointcloud_episode.upload_path(
+                    current_dataset_id, pcd_name, pcd_path, pcd_meta
+                )
+                pcd_id = info.id
+                frame_to_pointcloud_ids[idx] = pcd_id
+
+                # * Upload related images
+                image_jsons = []
+                camera_names = []
+                for img_path, rimage_info in lyft_helper.generate_rimage_infos(
+                    item._related_images, item.ann_data
+                ):
+                    img = api.pointcloud_episode.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_episode.add_related_images(image_jsons, camera_names)
+
+                # * Clean up
+                fs.silent_remove(pcd_path)
+                if log_progress:
+                    progress_cb(1)
+
+            try:
+                api.pointcloud_episode.annotation.append(
+                    current_dataset_id, ann_episode, frame_to_pointcloud_ids
+                )
+            except Exception as e:
+                error_msg = getattr(getattr(e, "response", e), "text", str(e))
+                logger.warn(
+                    f"Failed to upload annotation for scene: {scene}. Message: {error_msg}"
+                )
+            logger.info(f"Dataset ID:{current_dataset_id} has been successfully uploaded.")
+
+        if log_progress:
+            if is_development():
+                progress.close()

supervisely/io/exception_handlers.py

@@ -808,7 +808,8 @@ def handle_exception(exception: Exception) -> Union[HandleException, None]:
         for frame in stack[::-1]:
             if re.match(pattern, frame.line):
                 return handler(exception, stack)
-        if isinstance(exception.args[0], str) and re.match(pattern, exception.args[0]):
+        arg = next(iter(exception.args), None)
+        if isinstance(arg, str) and re.match(pattern, arg):
             return handler(exception, stack)
         if isinstance(exception, HTTPError):
             msg = exception.response.text

supervisely/io/fs.py

@@ -167,23 +167,28 @@ def list_dir_recursively(
 
 
 def list_files_recursively(
-    dir: str, valid_extensions: Optional[List[str]] = None, filter_fn=None
+    dir: str,
+    valid_extensions: Optional[List[str]] = None,
+    filter_fn=None,
+    ignore_valid_extensions_case: Optional[bool] = False,
 ) -> List[str]:
     """
     Recursively walks through directory and returns list with all file paths.
     Can be filtered by valid extensions and filter function.
 
-     :param dir: Target dir path.
-     :param dir: str
-     :param valid_extensions: List with valid file extensions.
-     :type valid_extensions: List[str], optional
-     :param filter_fn: Function with a single argument. Argument is a file path. Function determines whether to keep a given file path. Must return True or False.
-     :type filter_fn: Callable, optional
-     :returns: List with file paths
-     :rtype: :class:`List[str]`
-     :Usage example:
+    :param dir: Target dir path.
+    :param dir: str
+    :param valid_extensions: List with valid file extensions.
+    :type valid_extensions: List[str], optional
+    :param filter_fn: Function with a single argument. Argument is a file path. Function determines whether to keep a given file path. Must return True or False.
+    :type filter_fn: Callable, optional
+    :param ignore_valid_extensions_case: If True, validation of file extensions will be case insensitive.
+    :type ignore_valid_extensions_case: bool
+    :returns: List with file paths
+    :rtype: :class:`List[str]`
+    :Usage example:
 
-      .. code-block:: python
+     .. code-block:: python
 
          import supervisely as sly
 
@@ -198,12 +203,17 @@ def list_files_recursively(
             for filename in file_names:
                 yield os.path.join(dir_name, filename)
 
-    return [
-        file_path
-        for file_path in file_path_generator()
-        if (valid_extensions is None or get_file_ext(file_path) in valid_extensions)
-        and (filter_fn is None or filter_fn(file_path))
-    ]
+    valid_extensions = valid_extensions if ignore_valid_extensions_case is False else [ext.lower() for ext in valid_extensions]
+    files = []
+    for file_path in file_path_generator():
+        file_ext = get_file_ext(file_path)
+        if ignore_valid_extensions_case:
+            file_ext.lower()
+        if (
+            valid_extensions is None or file_ext in valid_extensions
+        ) and (filter_fn is None or filter_fn(file_path)):
+            files.append(file_path)
+    return files
 
 
 def list_files(

{supervisely-6.73.262.dist-info → supervisely-6.73.264.dist-info}/METADATA

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

{supervisely-6.73.262.dist-info → supervisely-6.73.264.dist-info}/RECORD

@@ -1,5 +1,5 @@
 supervisely/README.md,sha256=XM-DiMC6To3I9RjQZ0c61905EFRR_jnCUx2q3uNR-X8,3331
-supervisely/__init__.py,sha256=AV335r212Ln_vTroiucb5T6yFuAlMKxKzldjMbW3gA8,10800
+supervisely/__init__.py,sha256=x83gx4W-dVuR8-6vthw5nZptfR0k_1FLQfXs7H36c3Q,10800
 supervisely/_utils.py,sha256=I4nZ0L7NS6144r-CQ2VJvLeUJZ1bCi4pYXH4Gxo3-D4,15763
 supervisely/function_wrapper.py,sha256=R5YajTQ0GnRp2vtjwfC9hINkzQc0JiyGsu8TER373xY,1912
 supervisely/sly_logger.py,sha256=LG1wTyyctyEKuCuKM2IKf_SMPH7BzkTsFdO-0tnorzg,6225
@@ -23,7 +23,7 @@ supervisely/api/advanced_api.py,sha256=Nd5cCnHFWc3PSUrCtENxTGtDjS37_lCHXsgXvUI3T
 supervisely/api/agent_api.py,sha256=ShWAIlXcWXcyI9fqVuP5GZVCigCMJmjnvdGUfLspD6Y,8890
 supervisely/api/annotation_api.py,sha256=kB9l0NhQEkunGDC9fWjNzf5DdhqRF1tv-RRnIbkV2k0,64941
 supervisely/api/api.py,sha256=0dgPx_eizoCEFzfT8YH9uh1kq-OJwjrV5fBGD7uZ7E4,65840
-supervisely/api/app_api.py,sha256=-T4sISQ7POyR2yirf1kEWj4JaJFpJxCyRWqbf_99Jak,67036
+supervisely/api/app_api.py,sha256=RsbVej8WxWVn9cNo5s3Fqd1symsCdsfOaKVBKEUapRY,71927
 supervisely/api/dataset_api.py,sha256=eovT6l62jgjlRyCZ6IvoudUBfDxv9Hjj3Ap8IuCLd7I,41290
 supervisely/api/file_api.py,sha256=7yWt8lRQ4UfLmnMZ9T18UXzu8jihrtHtcqi6GZJG-0w,83414
 supervisely/api/github_api.py,sha256=NIexNjEer9H5rf5sw2LEZd7C1WR-tK4t6IZzsgeAAwQ,623
@@ -32,7 +32,7 @@ supervisely/api/image_api.py,sha256=2cki-IzA5jnN3QqqdSIbIbHJhDWxFGYxXY94WqBOoio,
 supervisely/api/import_storage_api.py,sha256=BDCgmR0Hv6OoiRHLCVPKt3iDxSVlQp1WrnKhAK_Zl84,460
 supervisely/api/issues_api.py,sha256=BqDJXmNoTzwc3xe6_-mA7FDFC5QQ-ahGbXk_HmpkSeQ,17925
 supervisely/api/labeling_job_api.py,sha256=odnzZjp29yM16Gq-FYkv-OA4WFMNJCLFo4qSikW2A7c,56280
-supervisely/api/module_api.py,sha256=ajVPU5bH1sB-l2PwWq_xtFxSmZIBikflousOxiAYmW4,43141
+supervisely/api/module_api.py,sha256=8z7K6K77fa9oijnix4vnCADJwe5nZtsDiWKZTWc_yuI,43273
 supervisely/api/neural_network_api.py,sha256=ktPVRO4Jeulougio8F0mioJJHwRJcX250Djp1wBoQ9c,7620
 supervisely/api/object_class_api.py,sha256=-rQcKwhBw3iL9KNH9c1ROgoimgWM1ls6Wi_tb1R-MzY,7683
 supervisely/api/plugin_api.py,sha256=TlfrosdRuYG4NUxk92QiQoVaOdztFspPpygyVa3M3zk,5283
@@ -560,12 +560,12 @@ supervisely/cli/teamfiles/teamfiles_upload.py,sha256=xnsW2rvdq1e-KGjF1tMBu7Oxh3n
 supervisely/collection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/collection/key_indexed_collection.py,sha256=x2UVlkprspWhhae9oLUzjTWBoIouiWY9UQSS_MozfH0,37643
 supervisely/collection/str_enum.py,sha256=Zp29yFGvnxC6oJRYNNlXhO2lTSdsriU1wiGHj6ahEJE,1250
-supervisely/convert/__init__.py,sha256=gRTV93OYJPI3FNfy78HO2SfR59qQ3FFKFSy_jw1adJ8,2571
-supervisely/convert/base_converter.py,sha256=5ZHYQO7n2xTM3mVORWGjmyzx2LP93IqFZABdORppxS4,18316
+supervisely/convert/__init__.py,sha256=fgJPpXP8jOt4lMbG0lYqWLOTDNcw695vINCqvZ0i6BA,2742
+supervisely/convert/base_converter.py,sha256=Y_uOUFJtqC44y_J6VsFB90hao8rrXkffV1ilxdj2T5o,18352
 supervisely/convert/converter.py,sha256=tWxTDfFv7hwzQhUQrBxzfr6WP8FUGFX_ewg5T2HbUYo,8959
 supervisely/convert/image/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/convert/image/image_converter.py,sha256=r-qdhuwOsk727mXIM26ucQhkoIKigu1M0BF-tw9IfGg,10321
-supervisely/convert/image/image_helper.py,sha256=RkBAyxxXmDG1Z5WFuO9kBDK8MN1Kl7Z25DX9-CwZ7OI,3647
+supervisely/convert/image/image_helper.py,sha256=fdV0edQD6hVGQ8TXn2JGDzsnrAXPDMacHBQsApzOME8,3677
 supervisely/convert/image/cityscapes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/convert/image/cityscapes/cityscapes_converter.py,sha256=msmsR2W-Xiod06dwn-MzmkbrEmQQqlKh7zyfTrW6YQw,7854
 supervisely/convert/image/cityscapes/cityscapes_helper.py,sha256=in5nR7__q_u5dCkVtZmynfZ_ZuvsIAHrTzyTG4EvNgU,2988
@@ -616,6 +616,9 @@ supervisely/convert/pointcloud/bag/bag_helper.py,sha256=2TFe49isZTxMhya-PApqLPxr
 supervisely/convert/pointcloud/las/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/convert/pointcloud/las/las_converter.py,sha256=prbvApwrjQ2cuDD9nAFBDkTLxtsN4jdjCZdNnkNow-g,1722
 supervisely/convert/pointcloud/las/las_helper.py,sha256=1gQ3OZLpe6D25CY_jXWDsrLBiS7nWfCgl3Zq--9TU14,1296
+supervisely/convert/pointcloud/lyft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervisely/convert/pointcloud/lyft/lyft_converter.py,sha256=bM9R3LLt4l5frK1Lhmy_WnhGUYCC7rH94v94sqmLxjY,11010
+supervisely/convert/pointcloud/lyft/lyft_helper.py,sha256=bTe7ryLPfSkW0MjzFP-6AMyDMBtPu8Xk9cx0g0MomoQ,8521
 supervisely/convert/pointcloud/ply/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/convert/pointcloud/ply/ply_converter.py,sha256=2ZCYkhJQzUev-sWGsBwCPtj1TGjdcx8o-Q--RAHavp8,2698
 supervisely/convert/pointcloud/ply/ply_helper.py,sha256=YfLiV9m6a4NNEMs0J32dmMTLffMLX4-JPTThMHOEK4w,268
@@ -626,6 +629,8 @@ supervisely/convert/pointcloud_episodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5J
 supervisely/convert/pointcloud_episodes/pointcloud_episodes_converter.py,sha256=ynqF1PSn3zWCD4SS7nvLE5eerAG1Nvj_StsoJ5JrNPg,6703
 supervisely/convert/pointcloud_episodes/bag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/convert/pointcloud_episodes/bag/bag_converter.py,sha256=jzWKXoFUWu11d5WlPfT1hphCubYpq_lhQZmhh07xZdQ,1659
+supervisely/convert/pointcloud_episodes/lyft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervisely/convert/pointcloud_episodes/lyft/lyft_converter.py,sha256=wdq_dO5Vejj0Df5Fuo-oQBWkEF1IGBr89XuBBHilGmM,10384
 supervisely/convert/pointcloud_episodes/sly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/convert/pointcloud_episodes/sly/sly_pointcloud_episodes_converter.py,sha256=7ONcZMOUJCNpmc0tmMX6FnNG0lu8Nj9K2SSTQHaSXFM,6188
 supervisely/convert/pointcloud_episodes/sly/sly_pointcloud_episodes_helper.py,sha256=h4WvNH6cEHtjxxhCnU7Hs2vkyJMye0qwabqXNYVTywE,3570
@@ -690,8 +695,8 @@ supervisely/imaging/image.py,sha256=1KNc4qRbP9OlI4Yta07Kc2ohAgSBJ_9alF9Jag74w30,
 supervisely/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/io/docker_utils.py,sha256=hb_HXGM8IYB0PF-nD7NxMwaHgzaxIFxofsUzQ_RCUZI,7935
 supervisely/io/env.py,sha256=rKLLw1XQqM3s3X3k3ke9Skyy5hPK0LE_xVUBq3Qko0Q,17284
-supervisely/io/exception_handlers.py,sha256=wvSP3Sp8HpAPSqri8rNAcitKO3I9dBfBp_somnmCA8A,36465
-supervisely/io/fs.py,sha256=2ZpAdt8zua423qSrmuXI71b52pGbZatgCeXqs48dufs,51322
+supervisely/io/exception_handlers.py,sha256=_nAgMFeE94bCxEvWakR82hMtdOJUyn7Gc7OymMxI9WI,36484
+supervisely/io/fs.py,sha256=Z92fU-UC7XHf-yQq431SwB7kyFODH3OqpxsfwowkuCY,51799
 supervisely/io/fs_cache.py,sha256=985gvBGzveLcDudgz10E4EWVjP9jxdU1Pa0GFfCBoCA,6520
 supervisely/io/github_utils.py,sha256=jGmvQJ5bjtACuSFABzrxL0jJdh14SezovrHp8T-9y8g,1779
 supervisely/io/json.py,sha256=VvyqXZl22nb6_DJK3TUOPetd5xq9xwRFKumWqsGs7iI,8679
@@ -1057,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.262.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.262.dist-info/METADATA,sha256=aMuL624leouIzMWfrL4bx-4A0hXHCT1hTTSHd9YYVbw,33573
-supervisely-6.73.262.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-supervisely-6.73.262.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.262.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.262.dist-info/RECORD,,
+supervisely-6.73.264.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.264.dist-info/METADATA,sha256=E6LgmO5fqJR74uJ6_FaxDXbPmh9pDGtQa4eegsSlkNI,33573
+supervisely-6.73.264.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+supervisely-6.73.264.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.264.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.264.dist-info/RECORD,,